NOM¶

gcc - Compilateur C et C++ du projet GNU

SYNOPSIS¶

gcc [-c⎪-S⎪-E] [-std=standard]
[-g] [-pg] [-Oniveau]
[-Wavertissement...] [-pedantic]
[-Irép...] [-Lrép...]
[-Dmacro[=déf]...] [-Umacro]
[-foption...] [-moption-machine...]
[-o fichier-sortie] fichier-entrée...

Seules les options les plus utiles sont listées ici ; voyez plus bas pour le reste. g++ accepte la plupart des options de gcc.

DESCRIPTION¶

Quand vous invoquez GCC, il effectue normalement le prétraitement, la compilation, l'assemblage et l'édition des liens. Les « options globales » vous permettent d'arrêter ce processus à une étape intermédiaire. Par exemple, l'option -c indique de ne pas lancer l'éditeur de liens. La sortie est alors constituée des fichiers objets produits par l'assembleur.

D'autres options peuvent être passées à l'une des étapes du traitement. Certaines options contrôlent le préprocesseur et d'autres le compilateur lui-même. D'autres options encore contrôlent l'assembleur et l'éditeur de liens ; la plupart d'entre elles ne sont pas documentées ici, puisque vous ne devez que rarement les utiliser.

La plupart des options de ligne de commandes que vous pouvez utiliser avec GCC sont utiles pour les programmes C ; quand une option n'est utile que pour un autre langage (habituellement C++), l'explication le précise explicitement. Si la description d'une option particulière ne mentionne pas de langage source, vous pouvez utiliser cette option avec tous les langages supportés.

Le programme gcc accepte des options et des noms de fichiers comme opérandes. Beaucoup d'options ont un nom composé de plusieurs lettres ; de multiples options composées d'une seule lettre ne peuvent dès lors pas être regroupées : -dr est très différent de -d -r.

Vous pouvez mélanger les options avec d'autres arguments. Pour la plupart, l'ordre utilisé n'est pas important. L'ordre est significatif quand vous utilisez plusieurs options du même type ; par exemple, si vous spécifiez -L plus d'une fois, les répertoires seront parcourus dans l'ordre spécifié.

Beaucoup d'options possèdent des noms longs débutant par -f ou par -W -- par exemple, -fforce-mem, -fstrength-reduce, -Wformat etc. La plupart d'entre elles possèdent à la fois les formes positive et négative ; la forme négative de -ffoo serait -fno-foo. Ce manuel ne documente que l'une de ces deux formes, en l'occurrence celle qui n'est pas utilisée par défaut.

OPTIONS¶

Résumé des options

Voici un résumé de toutes les options, groupées par type. Les explications suivent dans les prochaines sections.

Options globales

-c -S -E -o fichier -pipe -pass-exit-codes -x langage -v -### --target-help --help

Options du langage C

-ansi -std=standard -aux-info nom-fichier -fno-asm -fno-builtin -fno-builtin-fonction -fhosted -ffreestanding -trigraphs -no-integrated-cpp -traditional -traditional-cpp -fallow-single-precision -fcond-mismatch -fsigned-bitfields -fsigned-char -funsigned-bitfields -funsigned-char -fwritable-strings -fshort-wchar

Options du langage C++

-fno-access-control -fcheck-new -fconserve-space -fno-const-strings -fdollars-in-identifiers -fno-elide-constructors -fno-enforce-eh-specs -fexternal-templates -falt-external-templates -ffor-scope -fno-for-scope -fno-gnu-keywords -fno-implicit-templates -fno-implicit-inline-templates -fno-implement-inlines -fms-extensions -fno-nonansi-builtins -fno-operator-names -fno-optional-diags -fpermissive -frepo -fno-rtti -fstats -ftemplate-depth-n -fuse-cxa-atexit -fvtable-gc -fno-weak -nostdinc++ -fno-default-inline -Wabi -Wctor-dtor-privacy -Wnon-virtual-dtor -Wreorder -Weffc++ -Wno-deprecated -Wno-non-template-friend -Wold-style-cast -Woverloaded-virtual -Wno-pmf-conversions -Wsign-promo -Wsynth

Options du langage Objective-C

-fconstant-string-class=nom-classe -fgnu-runtime -fnext-runtime -gen-decls -Wno-protocol -Wselector

Options indépendantes du langage

-fmessage-length=n -fdiagnostics-show-location=[once⎪every-line]

Options d'avertissement

-fsyntax-only -pedantic -pedantic-errors -w -W -Wall -Waggregate-return -Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment -Wconversion -Wno-deprecated-declarations -Wdisabled-optimization -Wdiv-by-zero -Werror -Wfloat-equal -Wformat -Wformat=2 -Wformat-nonliteral -Wformat-security -Wimplicit -Wimplicit-int -Wimplicit-function-declaration -Werror-implicit-function-declaration -Wimport -Winline -Wlarger-than-longueur -Wlong-long -Wmain -Wmissing-braces -Wmissing-declarations -Wmissing-format-attribute -Wmissing-noreturn -Wmultichar -Wno-format-extra-args -Wno-format-y2k -Wno-import -Wpacked -Wpadded -Wparentheses -Wpointer-arith -Wredundant-decls -Wreturn-type -Wsequence-point -Wshadow -Wsign-compare -Wswitch -Wsystem-headers -Wtrigraphs -Wundef -Wuninitialized -Wunknown-pragmas -Wunreachable-code -Wunused -Wunused-function -Wunused-label -Wunused-parameter -Wunused-value -Wunused-variable -Wwrite-strings

Options d'avertissement spécifiques au C

-Wbad-function-cast -Wmissing-prototypes -Wnested-externs -Wstrict-prototypes -Wtraditional

Options de débogage

-dlettres -dumpspecs -dumpmachine -dumpversion -fdump-unnumbered -fdump-translation-unit[-n] -fdump-class-hierarchy[-n] -fdump-tree-original[-n] -fdump-tree-optimized[-n] -fdump-tree-inlined[-n] -fmem-report -fpretend-float -fprofile-arcs -ftest-coverage -ftime-report -g -gniveau -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2 -ggdb -gstabs -gstabs+ -gvms -gxcoff -gxcoff+ -p -pg -print-file-name=bibliothèque -print-libgcc-file-name -print-multi-directory -print-multi-lib -print-prog-name=programme -print-search-dirs -Q -save-temps -time

Options d'optimisation

-falign-functions=n -falign-jumps=n -falign-labels=n -falign-loops=n -fbranch-probabilities -fcaller-saves -fcprop-registers -fcse-follow-jumps -fcse-skip-blocks -fdata-sections -fdelayed-branch -fdelete-null-pointer-checks -fexpensive-optimizations -ffast-math -ffloat-store -fforce-addr -fforce-mem -ffunction-sections -fgcse -fgcse-lm -fgcse-sm -finline-functions -finline-limit=n -fkeep-inline-functions -fkeep-static-consts -fmerge-constants -fmerge-all-constants -fmove-all-movables -fno-default-inline -fno-defer-pop -fno-function-cse -fno-guess-branch-probability -fno-inline -fno-math-errno -fno-peephole -fno-peephole2 -funsafe-math-optimizations -fno-trapping-math -fomit-frame-pointer -foptimize-register-move -foptimize-sibling-calls -fprefetch-loop-arrays -freduce-all-givs -fregmove -frename-registers -frerun-cse-after-loop -frerun-loop-opt -fschedule-insns -fschedule-insns2 -fsingle-precision-constant -fssa -fssa-ccp -fssa-dce -fstrength-reduce -fstrict-aliasing -fthread-jumps -ftrapv -funroll-all-loops -funroll-loops --param nom=valeur -O -O0 -O1 -O2 -O3 -Os

Options du préprocesseur

-$ -Aquestion=réponse -A-question[=réponse] -C -dD -dI -dM -dN -Dmacro[=déf] -E -H -idirafter rép -include fichier -imacros fichier -iprefix fichier -iwithprefix rép -iwithprefixbefore rép -isystem rép -M -MM -MF -MG -MP -MQ -MT -nostdinc -P -remap -trigraphs -undef -Umacro -Wp,option

Option de l'assembleur

-Wa,option

Options de l'éditeur de liens

nom-fichier-objet -lbibliothèque -nostartfiles -nodefaultlibs -nostdlib -s -static -static-libgcc -shared -shared-libgcc -symbolic -Wl,option -Xlinker option -u symbole

Options de répertoires

-Bpréfixe -Irép -I- -Lrép -specs=fichier

Options de cible

-b machine -V version

Options dépendantes de la machine

Options M680x0

-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040 -m68060 -mcpu32 -m5200 -m68881 -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield -mrtd -mshort -msoft-float -mpcrel -malign-int -mstrict-align

Options IM68hc1x

-m6811 -m6812 -m68hc11 -m68hc12 -mauto-incdec -mshort -msoft-reg-count=nombre

Options VAX

-mg -mgnu -munix

Options SPARC

-mcpu=type-cpu -mtune=type-cpu -mcmodel=modèle-code -m32 -m64 -mapp-regs -mbroken-saverestore -mcypress -mfaster-structs -mflat -mfpu -mhard-float -mhard-quad-float -mimpure-text -mlive-g0 -mno-app-regs -mno-faster-structs -mno-flat -mno-fpu -mno-impure-text -mno-stack-bias -mno-unaligned-doubles -msoft-float -msoft-quad-float -msparclite -mstack-bias -msupersparc -munaligned-doubles -mv8

Options Convex

-mc1 -mc2 -mc32 -mc34 -mc38 -margcount -mnoargcount -mlong32 -mlong64 -mvolatile-cache -mvolatile-nocache

Options AMD29K

-m29000 -m29050 -mbw -mnbw -mdw -mndw -mlarge -mnormal -msmall -mkernel-registers -mno-reuse-arg-regs -mno-stack-check -mno-storem-bug -mreuse-arg-regs -msoft-float -mstack-check -mstorem-bug -muser-registers

Options ARM

-mapcs-frame -mno-apcs-frame -mapcs-26 -mapcs-32 -mapcs-stack-check -mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reentrant -mno-apcs-reentrant -msched-prolog -mno-sched-prolog -mlittle-endian -mbig-endian -mwords-little-endian -malignment-traps -mno-alignment-traps -msoft-float -mhard-float -mfpe -mthumb-interwork -mno-thumb-interwork -mcpu=nom -march=nom -mfpe=nom -mstructure-size-boundary=n -mbsd -mxopen -mno-symrename -mabort-on-noreturn -mlong-calls -mno-long-calls -msingle-pic-base -mno-single-pic-base -mpic-register=reg -mnop-fun-dllimport -mpoke-function-name -mthumb -marm -mtpcs-frame -mtpcs-leaf-frame -mcaller-super-interworking -mcallee-super-interworking

Options MN10200

-mrelax

Options MN10300

-mmult-bug -mno-mult-bug -mam33 -mno-am33 -mno-crt0 -mrelax

Options M32R/D

-m32rx -m32r -mcode-model=type-modèle -msdata=type-sdata -G nombre

Options M88K

-m88000 -m88100 -m88110 -mbig-pic -mcheck-zero-division -mhandle-large-shift -midentify-revision -mno-check-zero-division -mno-ocs-debug-info -mno-ocs-frame-position -mno-optimize-arg-area -mno-serialize-volatile -mno-underscores -mocs-debug-info -mocs-frame-position -moptimize-arg-area -mserialize-volatile -mshort-data-nombre -msvr3 -msvr4 -mtrap-large-shift -muse-div-instruction -mversion-03.00 -mwarn-passed-structs

Options RS/6000 et PowerPC

-mcpu=type-cpu -mtune=type-cpu -mpower -mno-power -mpower2 -mno-power2 -mpowerpc -mpowerpc64 -mno-powerpc -maltivec -mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt -mnew-mnemonics -mold-mnemonics -mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc -m64 -m32 -mxl-call -mno-xl-call -mpe -msoft-float -mhard-float -mmultiple -mno-multiple -mstring -mno-string -mupdate -mno-update -mfused-madd -mno-fused-madd -mbit-align -mno-bit-align -mstrict-align -mno-strict-align -mrelocatable -mno-relocatable -mrelocatable-lib -mno-relocatable-lib -mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian -mcall-aix -mcall-sysv -mcall-netbsd -maix-struct-return -msvr4-struct-return -mabi=altivec -mabi=no-altivec -mprototype -mno-prototype -msim -mmvme -mads -myellowknife -memb -msdata -msdata=opt -mvxworks -G nombre -pthread

Options RT

-mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs -mfull-fp-blocks -mhc-struct-return -min-line-mul -mminimum-fp-blocks -mnohc-struct-return

Options MIPS

-mabicalls -march=type-cpu -mtune=type-cpu -mcpu=type-cpu -membedded-data -muninit-const-in-rodata -membedded-pic -mfp32 -mfp64 -mfused-madd -mno-fused-madd -mgas -mgp32 -mgp64 -mgpopt -mhalf-pic -mhard-float -mint64 -mips1 -mips2 -mips3 -mips4 -mlong64 -mlong32 -mlong-calls -mmemcpy -mmips-as -mmips-tfile -mno-abicalls -mno-embedded-data -mno-uninit-const-in-rodata -mno-embedded-pic -mno-gpopt -mno-long-calls -mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats -mrnames -msoft-float -m4650 -msingle-float -mmad -mstats -EL -EB -G nombre -nocpp -mabi=32 -mabi=n32 -mabi=64 -mabi=eabi -mfix7000 -mno-crt0 -mflush-func=fonc -mno-flush-func

Options i386 et x86-64

-mcpu=type-cpu -march=type-cpu -mfpmath=unité -masm=dialecte -mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib -mno-wide-multiply -mrtd -malign-double -mpreferred-stack-boundary=nombre -mmmx -msse -msse2 -msse-math -m3dnow -mthreads -mno-align-stringops -minline-all-stringops -mpush-args -maccumulate-outgoing-args -m128bit-long-double -m96bit-long-double -mregparm=nombre -momit-leaf-frame-pointer -mno-red-zone -mcmodel=modèle-code -m32 -m64

Options HPPA

-march=type-architecture -mbig-switch -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls -mgas -mjump-in-delay -mlong-load-store -mno-big-switch -mno-disable-fpregs -mno-disable-indexing -mno-fast-indirect-calls -mno-gas -mno-jump-in-delay -mno-long-load-store -mno-portable-runtime -mno-soft-float -mno-space-regs -msoft-float -mpa-risc-1-0 -mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime -mschedule=type-cpu -mspace-regs

Options Intel 960

-mtype-cpu -masm-compat -mclean-linkage -mcode-align -mcomplex-addr -mleaf-procedures -mic-compat -mic2.0-compat -mic3.0-compat -mintel-asm -mno-clean-linkage -mno-code-align -mno-complex-addr -mno-leaf-procedures -mno-old-align -mno-strict-align -mno-tail-call -mnumerics -mold-align -msoft-float -mstrict-align -mtail-call

Options DEC Alpha

-mno-fp-regs -msoft-float -malpha-as -mgas -mieee -mieee-with-inexact -mieee-conformant -mfp-trap-mode=mode -mfp-rounding-mode=mode -mtrap-precision=mode -mbuild-constants -mcpu=type-cpu -mtune=type-cpu -mbwx -mmax -mfix -mcix -mfloat-vax -mfloat-ieee -mexplicit-relocs -msmall-data -mlarge-data -mmemory-latency=temps

Options DEC Alpha/VMS

-mvms-return-codes

Options Clipper

-mc300 -mc400

Options H8/300

-mrelax -mh -ms -mint32 -malign-300

Options SH

-m1 -m2 -m3 -m3e -m4-nofpu -m4-single-only -m4-single -m4 -m5-64media -m5-64media-nofpu -m5-32media -m5-32media-nofpu -m5-compact -m5-compact-nofpu -mb -ml -mdalign -mrelax -mbigtable -mfmovd -mhitachi -mnomacsave -mieee -misize -mpadstruct -mspace -mprefergot -musermode

Options System V

-Qy -Qn -YP,chemins -Ym,rép

Options ARC

-EB -EL -mmangle-cpu -mcpu=cpu -mtext=section-texte -mdata=section-données -mrodata=section-données-lecture-seule

Options TMS320C3x/C4x

-mcpu=cpu -mbig -msmall -mregparm -mmemparm -mfast-fix -mmpyi -mbk -mti -mdp-isr-reload -mrpts=nombre -mrptb -mdb -mloop-unsigned -mparallel-insns -mparallel-mpy -mpreserve-float

Options V850

-mlong-calls -mno-long-calls -mep -mno-ep -mprolog-function -mno-prolog-function -mspace -mtda=n -msda=n -mzda=n -mv850 -mbig-switch

Options NS32K

-m32032 -m32332 -m32532 -m32081 -m32381 -mmult-add -mnomult-add -msoft-float -mrtd -mnortd -mregparam -mnoregparam -msb -mnosb -mbitfield -mnobitfield -mhimem -mnohimem

Options AVR

-mmcu=mcu -msize -minit-stack=n -mno-interrupts -mcall-prologues -mno-tablejump -mtiny-stack

Options MCore

-mhardlit -mno-hardlit -mdiv -mno-div -mrelax-immediates -mno-relax-immediates -mwide-bitfields -mno-wide-bitfields -m4byte-functions -mno-4byte-functions -mcallgraph-data -mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim -mlittle-endian -mbig-endian -m210 -m340 -mstack-increment

Options MMIX

-mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi=gnu -mabi=mmixware -mzero-extend -mknuthdiv -mtoplevel-symbols -melf -mbranch-predict -mno-branch-predict -mbase-addresses -mno-base-addresses

Options IA-64

-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic -mvolatile-asm-stop -mb-step -mregister-names -mno-sdata -mconstant-gp -mauto-pic -minline-divide-min-latency -minline-divide-max-throughput -mno-dwarf2-asm -mfixed-range=intervalle-registres

Options ID30V

-mextmem -mextmemory -monchip -mno-asm-optimize -masm-optimize -mbranch-cost=n -mcond-exec=n

Options IS/390 et zSeries

-mhard-float -msoft-float -mbackchain -mno-backchain -msmall-exec -mno-small-exec -mmvcle -mno-mvcle -m64 -m31 -mdebug -mno-debug

Options CRIS

-mcpu=cpu -march=cpu -mtune=cpu -mmax-stack-frame=n -melinux-stacksize=n -metrax4 -metrax100 -mpdebug -mcc-init -mno-side-effects -mstack-align -mdata-align -mconst-align -m32-bit -m16-bit -m8-bit -mno-prologue-epilogue -mno-gotplt -melf -maout -melinux -mlinux -sim -sim2

Options PDP-11

-mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10 -mbcopy -mbcopy-builtin -mint32 -mno-int16 -mint16 -mno-int32 -mfloat32 -mno-float64 -mfloat64 -mno-float32 -mabshi -mno-abshi -mbranch-expensive -mbranch-cheap -msplit -mno-split -munix-asm -mdec-asm

Options Xstormy16

-msim

Options Xtensa

-mbig-endian -mlittle-endian -mdensity -mno-density -mmac16 -mno-mac16 -mmul16 -mno-mul16 -mmul32 -mno-mul32 -mnsa -mno-nsa -mminmax -mno-minmax -msext -mno-sext -mbooleans -mno-booleans -mhard-float -msoft-float -mfused-madd -mno-fused-madd -mserialize-volatile -mno-serialize-volatile -mtext-section-literals -mno-text-section-literals -mtarget-align -mno-target-align -mlongcalls -mno-longcalls

Options de génération de code

-fcall-saved-reg -fcall-used-reg -ffixed-registre -fexceptions -fnon-call-exceptions -funwind-tables -fasynchronous-unwind-tables -finhibit-size-directive -finstrument-functions -fno-common -fno-ident -fno-gnu-linker -fpcc-struct-return -fpic -fPIC -freg-struct-return -fshared-data -fshort-enums -fshort-double -fvolatile -fvolatile-global -fvolatile-static -fverbose-asm -fpack-struct -fstack-check -fstack-limit-register=reg -fstack-limit-symbol=sym -fargument-alias -fargument-noalias -fargument-noalias-global -fleading-underscore -ftls-model=modèle

Options contrôlant le type de sortie

La compilation peut impliquer jusqu'à quatre étapes : prétraitement, compilation proprement dite, assemblage et édition des liens, toujours dans cet ordre. Les trois premières étapes s'appliquent à un fichier source individuel, et se terminent en produisant un fichier objet ; l'édition des liens combine tous les fichiers objets (ceux nouvellement compilés, et ceux spécifiés en entrée) en un fichier exécutable.

Pour tout fichier d'entrée, le suffixe du nom de fichier détermine le type de compilation qui est effectuée :

fichier.c

Code source C qui doit être prétraité.

fichier.i

Code source C qui ne devrait pas être prétraité.

fichier.ii

Code source C++ qui ne devrait pas être prétraité.

fichier.m

Code source Objective-C. Notez que vous devez lier un programme Objective-C avec la bibliothèque libobjc.a pour le faire fonctionner.

fichier.mi

Code source Objective-C qui ne devrait pas être prétraité.

fichier.h

Fichier d'en-tête C (ne doit être ni compilé, ni lié).

fichier.cc

fichier.cp

fichier.cxx

fichier.cpp

fichier.c++

fichier.C

Code source C++ qui ne devrait pas être prétraité. Notez que pour .cxx, les deux dernières lettres doivent être littéralement x. De la même façon, .C se réfère à un C littéral en majuscule.

fichier.f

fichier.for

fichier.FOR

Code source Fortran qui ne devrait pas être prétraité.

fichier.F

fichier.fpp

fichier.FPP

Code source Fortran qui doit être prétraité (avec le préprocesseur traditionnel).

fichier.r

Code source Fortran qui doit être prétraité avec un préprocesseur RATFOR (non inclus avec GCC).

fichier.ads

Fichier de code source Ada qui contient une déclaration d'unité de bibliothèque (la déclaration d'un paquet, d'un sous-programme, ou d'un générique, ou d'une instanciation générique), ou une déclaration de renommage d'unité de bibliothèque (un paquet, un générique, ou une déclaration de renommage d'un sous-programme). De tels fichiers sont également appelés specs.

fichier.adb

Fichier de code source Ada qui contient le corps d'une unité de bibliothèque (le corps d'un sous-programme ou d'un paquetage). De tels fichiers sont également appelés corps (bodies).

fichier.s

Code assembleur.

fichier.S

Code assembleur qui doit être prétraité.

autre

Un fichier objet à envoyer directement à l'éditeur de liens. Tout nom de fichier de suffixe non reconnu est traité de cette manière.

Vous pouvez spécifier explicitement le langage d'entrée avec l'option -x :

-x langage

Spécifier explicitement le langage pour les fichiers d'entrée suivants (plutôt que de laisser choisir par le compilateur un langage par défaut basé sur le suffixe du nom de fichier). Cette option s'applique à tous les fichiers d'entrée subséquents jusqu'à l'option -x suivante. Les valeurs possibles pour langage sont :

        c  c-header  cpp-output
        c++  c++-cpp-output
        objective-c  objc-cpp-output
        assembler  assembler-with-cpp
        ada
        f77  f77-cpp-input  ratfor
        java
    

-x none

Désactiver toute spécification de langage, afin que les fichiers ultérieurs soient traités en fonction de leur suffixe de nom de fichier (comme si -x n'avait jamais été utilisé).

-pass-exit-codes

Normalement, le programme gcc se terminera avec un code de retour de 1 si une phase de compilation quelconque renvoie un code de retour d'erreur. Si vous spécifiez -pass-exit-codes, le programme gcc renverra à la place le code d'erreur numériquement le plus grand produit par une phase se terminant sur une indication d'erreur.

Si vous ne désirez que certaines étapes de la compilation, vous pouvez utiliser -x (ou des suffixes de noms de fichiers) pour indiquer à gcc où il doit démarrer, et une des options -c, -S ou -E pour lui dire où il doit s'arrêter. Notez que certaines combinaisons (par exemple -x cpp-output -E) disent à gcc de ne rien faire du tout.

-c

Compiler ou assembler les fichiers sources, mais ne pas éditer les liens. L'étape d'édition des liens n'est tout simplement pas effectuée. La sortie finale du compilateur correspond à un fichier objet pour chaque fichier source.

Par défaut, le nom du fichier objet pour un fichier source donné est formé en remplaçant les suffixes .c, .i, .s, etc., par .o.

Les fichiers d'entrée non reconnus, ne requérant ni compilation ni assemblage, sont ignorés.

-S

S'arrêter après l'étape de la compilation proprement dite ; ne pas assembler. La sortie est un fichier de code assembleur pour chaque fichier d'entrée non assembleur spécifié.

Par défaut, GCC crée le nom du fichier assembleur à partir du fichier source en remplaçant les suffixes .c, .i, etc., par .s.

Les fichiers d'entrée ne requérant pas de compilation sont ignorés.

-E

S'arrêter après l'étape du prétraitement ; ne pas véritablement lancer le compilateur. La sortie est un code source prétraité, qui est envoyé vers la sortie standard.

Les fichiers d'entrée ne requérant pas de compilation sont ignorés.

-o fichier

Placer la sortie dans fichier. Cela s'applique quel que soit le type de sortie produite, que ce soit un fichier exécutable, un fichier objet, un fichier assembleur ou du code C prétraité.

Puisqu'un seul fichier de sortie peut être spécifié, cela n'a aucun sens d'utiliser -o quand on compile plus d'un fichier d'entrée, à moins que l'on ne veuille produire un fichier exécutable en sortie.

Si -o n'est pas spécifié, le comportement par défaut est de produire un fichier exécutable nommé a.out, un fichier objet pour source.suffixe nommé source.o, son fichier assembleur dans source.s, et tout le code source C prétraité sur la sortie standard.

-v

Afficher (sur la sortie d'erreur standard) les commandes exécutées pour lancer les étapes de la compilation. Afficher également le numéro de version du programme pilote du compilateur, du préprocesseur et du compilateur proprement dit.

-###

Comme -v sauf que les commandes ne sont pas exécutées et que tous les arguments de commande sont protégés. C'est utile pour que les scripts shell puissent capturer les lignes de commandes générées par le pilote.

-pipe

Utiliser des tubes plutôt que des fichiers temporaires pour la communication entre les différentes phases de la compilation. Ceci ne marche pas sur certains systèmes où l'assembleur ne peut lire à partir d'un tube, mais cela ne pose aucun problème dans le cas de l'assembleur GNU.

--help

Afficher (sur la sortie standard) une description des options de ligne de commandes comprises par gcc. Si l'option -v est également spécifiée, alors --help sera également passé aux différents processus invoqués par gcc, afin qu'ils puissent afficher les options de ligne de commandes qu'ils acceptent. Si l'option -W est également spécifiée, alors les options de ligne de commandes qui ne possèdent pas de documentation associée seront également affichées.

--target-help

Afficher (sur la sortie standard) une description des options de ligne de commandes spécifiques à une cible pour chaque outil.

Compiler des programmes C++

Les fichiers sources C++ utilisent par convention l'un des suffixes .C, .cc, .cpp, .c++, .cp ou .cxx ; les fichiers C++ prétraités utilisent le suffixe .ii. GCC reconnaît les fichiers portant ces noms et les compile en tant que programmes C++ même si vous appelez le compilateur de la même manière que pour compiler des programmes C (d'habitude avec le nom gcc).

Néanmoins, les programmes C++ requièrent souvent des bibliothèques de classes de même qu'un compilateur comprenant le langage C++ (et dans certaines circonstances, vous pourriez compiler des programmes à partir de l'entrée standard, ou bien sans un suffixe qui les désigne comme étant des programmes C++). g++ est un programme qui appelle GCC avec le langage par défaut fixé à C++, et il spécifie automatiquement une édition des liens utilisant la bibliothèque C++. Sur de nombreux systèmes, g++ est également installé sous le nom c++.

Quand vous compilez des programmes C++, vous pouvez spécifier la plupart des options de ligne de commandes que vous utiliseriez pour compiler des programmes dans n'importe quel langage, ou bien des options de ligne de commandes possédant une signification pour le C et les langages associés, ou encore des options qui ne sont significatives que pour les programmes C++.

Options contrôlant le dialecte C

Les options suivantes contrôlent le dialecte de C (ou des langages dérivés de C, comme C++ et Objective-C) que le compilateur accepte :

-ansi

Dans le mode C, supporter tous les programmes ISO C89. Dans le mode C++, supprimer les extensions GNU en conflit avec le C++ ISO.

Cela désactive certaines fonctionnalités de GCC qui sont incompatibles avec le C89 ISO (pendant la compilation de code C), ou du C++ standard (pendant la compilation de code C++), comme les mots-clés « asm » et « typeof », et les macros prédéfinies comme « unix » et « vax » qui identifient le type de système que vous utilisez. Cela active également la fonctionnalité rarement utilisée et non souhaitable des trigraphes ISO. Pour le compilateur C, cette option désactive la reconnaissance des commentaires // de style C++, ainsi que le mot-clé « inline ».

Les mots-clés alternatifs « __asm__ », « __extension__ », « __inline__ » et « __typeof__ » continuent à fonctionner malgré -ansi. Vous ne les utilisez naturellement pas dans un programme C ISO, mais il est utile de les trouver dans des fichiers d'en-tête pouvant être inclus lors de compilations effectuées avec -ansi. Des macros prédéfinies alternatives comme « __unix__ » et « __vax__ » sont aussi disponibles, avec ou sans -ansi.

L'option -ansi ne provoque pas le rejet arbitraire des programmes non ISO. Pour cela, -pedantic est requis en plus de -ansi.

La macro « __STRICT_ANSI__ » est prédéfinie quand l'option -ansi est utilisée. Certains fichiers d'en-tête peuvent remarquer cette macro, et s'empêcher de déclarer certaines fonctions ou de définir certaines macros que ne demande pas le standard ISO, afin d'éviter d'interférer avec un programme quelconque qui utiliserait ces noms pour d'autres choses.

Les fonctions qui devraient normalement être intégrées mais qui ne possèdent pas la sémantique définie par le C ISO (comme « alloca » et « ffs ») ne sont pas des fonctions intégrées quand -ansi est utilisé.

-std=

Déterminer le standard du langage. Cette option n'est actuellement supportée que lors de la compilation de C. Il faut fournir une valeur pour cette option ; les valeurs possibles sont

-aux-info nom-fichier

Sortir dans le nom de fichier donné les déclarations prototypées pour toutes les fonctions déclarées et/ou définies dans une unité de traduction, ce qui inclut celles présentes dans les fichiers d'en-tête. Cette option est silencieusement ignorée pour tout langage autre que C.

En plus des déclarations, le fichier indique, en commentaire, l'origine de chaque déclaration (fichier source et numéro de ligne), si la déclaration était implicite, prototypée ou non (I, N pour new (nouveau) ou O pour old (ancien), respectivement, dans le premier caractère suivant le numéro de ligne et le signe deux-points), et si elle provenait d'une déclaration ou d'une définition (C ou F, respectivement, dans le caractère suivant). Dans le cas des définitions de fonctions, une liste d'arguments du style K&R suivis de leur déclaration est également fournie, à l'intérieur des commentaires, après la déclaration.

-fno-asm

Ne pas reconnaître « asm », « inline » ou « typeof » comme des mots-clés, afin que le code puisse utiliser ces mots comme identificateurs. Vous pouvez utiliser les mots-clés « __asm__ », « __inline__ » et « __typeof__ » à la place. -ansi implique -fno-asm.

En C++, cet interrupteur n'affecte que le mot-clé « typeof », puisque « asm » et « inline » sont des mots-clés standard. Vous pourriez utiliser l'indicateur -fno-gnu-keywords à la place, qui a le même effet. Dans le mode C99 (-std=c99 ou -std=gnu99), cet interrupteur n'affecte que les mots-clés « asm » et « typeof », puisque « inline » est un mot-clé standard du C99 ISO.

-fno-builtin

-fno-builtin-fonction (C et Objective-C uniquement)

Ne pas reconnaître les fonctions intégrées qui ne commencent pas par le préfixe __builtin_.

GCC génère normalement du code spécial pour manipuler certaines fonctions intégrées plus efficacement ; par exemple, les appels à « alloca » peuvent devenir des instructions uniques qui ajustent la pile directement, et les appels à « memcpy » peuvent devenir des boucles de copie en ligne. Le code résultant est souvent plus concis et rapide mais, puisque les appels de fonction n'apparaissent plus en tant que tels, vous ne pouvez pas placer de point d'arrêt sur ces appels, ni ne pouvez modifier le comportement des fonctions en les liant à une bibliothèque différente.

En C++, -fno-builtin est toujours utilisé. L'option -fbuiltin n'a aucun effet. Donc, en C++, la seule façon d'obtenir les bénéfices d'optimisation des fonctions intégrées est d'appeler la fonction en utilisant le préfixe __builtin_. La Bibliothèque Standard GNU C++ utilise des fonctions intégrées pour implémenter de nombreuses fonctions (comme « std::strchr »), pour que vous obteniez automatiquement un code efficace.

Avec l'option -fno-builtin-fonction, non disponible lors de la compilation de C++, seule la fonction intégrée fonction est désactivée. fonction ne doit pas commencer par __builtin_. Si une fonction désignée n'est pas intégrée dans cette version de GCC, cette option est ignorée. Il n'y a pas d'option -fbuiltin-function correspondante ; si vous voulez activer des fonctions intégrées de façon sélective quand vous utilisez -fno-builtin ou -ffreestanding, vous pouvez définir des macros comme :

        #define abs(n)          __builtin_abs ((n))
        #define strcpy(d, s)    __builtin_strcpy ((d), (s))
    

-fhosted

Supposer que la compilation a lieu dans un environnement hôte. Cela implique -fbuiltin. Un environnement hôte est un environnement dans lequel la bibliothèque standard entière est disponible, et dans lequel « main » a un type de retour « int ». Les exemples se rencontrent pratiquement partout sauf dans un noyau. C'est équivalent à -fno-freestanding.

-ffreestanding

Supposer que la compilation a lieu dans un environnement autonome. Cela implique -fno-builtin. Un environnement autonome est un environnement dans lequel la bibliothèque standard peut ne pas exister, et où le démarrage du programme n'est pas nécessairement placé dans « main ». L'exemple le plus évident est un noyau de système d'exploitation. C'est équivalent à -fno-hosted.

-trigraphs

Supporter les trigraphes C ISO C. L'option -ansi (et les options -std pour une conformité stricte au C ISO) implique -trigraphs.

-no-integrated-cpp

Invoquer le cpp externe durant la compilation. Le comportement par défaut est d'utiliser le cpp intégré (cpp interne). Cette option permet également l'utilisation d'un cpp fourni par l'utilisateur via l'option -B. Cet indicateur est applicable dans les modes C et C++.

Nous ne garantissons pas le maintien de cette option dans le futur, et nous pourrions modifier sa sémantique.

-traditional

Essayer de supporter certains aspects des compilateurs C traditionnels. Spécifiquement :

-traditional-cpp

Essayer de supporter certains aspects des préprocesseurs C traditionnels. Voyez le manuel de GNU CPP pour les détails.

-fcond-mismatch

Autoriser des expressions conditionnelles avec des types non concordants dans les deuxième et troisième arguments. La valeur d'une telle expression est void. Cette option n'est pas supportée pour le C++.

-funsigned-char

Permettre au type « char » d'être non signé, comme « unsigned char ».

Chaque type de machine a son propre avis concernant ce que doit représenter le type « char ». C'est soit « unsigned char » par défaut, soit « signed char » par défaut.

Idéalement, un programme portable devrait toujours utiliser « signed char » ou « unsigned char » quand il dépend du signe d'un objet. Mais beaucoup de programmes ont été écrits pour utiliser des « char » simples et s'attendent à ce qu'ils soient signés, ou à ce qu'il soient non signés, en fonction des machines pour lesquelles le programme a été écrit. Cette option, et son inverse, vous permettent de créer un programme qui fonctionne avec le comportement opposé par défaut.

Le type « char » est toujours un type distinct de « signed char » et « unsigned char », même si son comportement est toujours celui d'un de ces deux là.

-fsigned-char

Permettre au type « char » d'être signé, comme « signed char ».

Notez que c'est équivalent à -fno-unsigned-char, qui est la forme négative de -funsigned-char. De même, l'option -fno-signed-char est équivalente à -funsigned-char.

-fsigned-bitfields

-funsigned-bitfields

-fno-signed-bitfields

-fno-unsigned-bitfields

Ces options contrôlent si un champ-bit est signé ou non signé, quand la déclaration n'utilise ni « signed » ni « unsigned ». Par défaut, un tel champ-bit d'un bit est signé, parce que c'est logique : les types entiers de bases tels que « int » sont des types signés.

Néanmoins, lorsque -traditional est utilisé, les champs-bits sont tous considérés comme étant non signés.

-fwritable-strings

Conserve les constantes de type chaîne de caractères dans le segment de données accessible en écriture et ne les rend pas uniques, dans un but de compatibilité avec d'anciens programmes qui supposent qu'ils peuvent écrire dans des constantes de type chaîne de caractères. L'option -traditional a également cet effet.

Écrire dans des constantes de type chaîne de caractères est une très mauvaise idée ; les « constantes » devraient réellement l'être.

-fallow-single-precision

Ne pas promouvoir des opérations mathématiques simple précision en double précision, même lors d'une compilation avec -traditional.

Le C traditionnel K&R C promeut toutes les opérations flottantes en double précision, quelle que soit la taille des opérandes. Sur l'architecture pour laquelle vous compilez, la simple précision peut être plus rapide que la double précision. Si vous devez utiliser -traditional, mais que vous voulez utiliser des opérations en simple précision quand les opérandes sont en simple précision, utilisez cette option. Cette option n'a aucun effet lors d'une compilation utilisant les conventions C ISO ou GNU (comportement par défaut).

-fshort-wchar

Surcharger le type sous-jacent de wchar_t pour qu'il soit short unsigned int au lieu du comportement par défaut pour la cible. Cette option est utile pour la construction de programmes devant tourner sous WINE.

Options contrôlant le dialecte C++

Cette section décrit les options de ligne de commandes qui ne sont significatives que pour les programmes C++, mais vous pouvez également utiliser la plupart des options du compilateur GNU quel que soit le langage dans lequel votre programme est écrit. Par exemple, vous pouvez compiler un fichier « premièreClasse.C » comme ceci :

        g++ -g -frepo -O -c premièreClasse.C

Dans cet exemple, seule -frepo est une option destinée exclusivement aux programmes C++ ; vous pouvez utiliser les autres options avec n'importe quel langage supporté par GCC.

Voici une liste des options qui sont disponibles uniquement lors de la compilation de programmes C++ :

-fno-access-control

Désactiver tout contrôle d'accès. Cet interrupteur est principalement utile pour contourner des bogues dans le code de contrôle d'accès.

-fcheck-new

Vérifier que le pointeur renvoyé par « operator new » est non-null avant de tenter de modifier la mémoire allouée. Le document de travail actuel requiert que « operator new » ne renvoie jamais un pointeur null, de sorte que cette vérification n'est normalement pas nécessaire.

Une alternative à l'utilisation de cette option est de spécifier que votre « operator new » ne lance aucune exception ; si vous le déclarez throw(), G++ vérifiera la valeur de retour. Voyez également new (nothrow).

-fconserve-space

Placer les variables globales non initialisées ou initialisées à l'exécution dans le segment commun, comme en C. Cela économise de l'espace dans l'exécutable au prix d'un non diagnostic des définitions dupliquées. Si vous compilez avec ce drapeau et que votre programme se plante mystérieusement après que « main() » se soit terminé, il se peut qu'un objet est détruit deux fois du fait de la fusion de deux définitions.

Cette option n'est plus utile sur la plupart des cibles, maintenant que le support a été ajouté pour placer des variables dans le BSS sans les rendre communes.

-fno-const-strings

Donner aux chaînes de caractères constantes le type « char * » au lieu du type « const char * ». Par défaut, G++ utilise le type « const char * » comme requis par le standard. Même si vous utilisez -fno-const-strings, vous ne pouvez pas réellement modifier la valeur d'une chaîne de caractères constantes, à moins que vous n'utilisiez également -fwritable-strings.

Cette option pourrait être supprimée dans une prochaine version de G++. Pour une portabilité maximale, vous devriez structurer votre code de sorte qu'il fonctionne avec des chaînes de caractères constantes qui ont le type « const char * ».

-fdollars-in-identifiers

Accepter les $ dans les identificateurs. Vous pouvez également interdire explicitement l'utilisation du $ avec l'option -fno-dollars-in-identifiers. (GNU C autorise les $ par défaut sur la plupart des systèmes cibles, mais il y a quelques exceptions.) Le C traditionnel permettait au caractère $ de faire partie des identificateurs. Néanmoins, le C et le C++ ISO interdisent le $ dans les identificateurs.

-fno-elide-constructors

Le standard C++ permet à une implémentation d'omettre de créer un objet temporaire qui n'est utilisé que pour initialiser un autre objet du même type. Spécifier cette option désactive cette optimisation, et force G++ à toujours appeler le constructeur de copie.

-fno-enforce-eh-specs

Ne pas rechercher de violation des spécifications d'exceptions au moment de l'exécution. Cette option viole le standard C++, mais peut être utile pour réduire la taille du code dans du code de production, un peu comme quand on définit NDEBUG. Le compilateur optimisera toujours en fonction des spécifications d'exceptions.

-fexternal-templates

Forcer les #pragma interface et implementation à s'appliquer aux instanciations de modèles ; les instances de modèle sont émises ou pas en fonction de l'emplacement de la définition de modèle.

Cette option est dépréciée.

-falt-external-templates

Similaire à -fexternal-templates, mais les instances de modèle sont émises ou pas en fonction de l'emplacement où elles sont instanciées pour la première fois.

Cette option est dépréciée.

-ffor-scope

-fno-for-scope

Si -ffor-scope est spécifié, la portée des variables déclarées dans une instruction-for-init est limitée à la boucle for elle-même, comme spécifié par le standard C++ standard. Si -fno-for-scope est spécifié, la portée des variables déclarées dans une instruction-for-init s'étend jusqu'à la fin de la portée entourante, comme c'était le cas dans d'anciennes versions de G++, et dans d'autres implémentations (traditionnelles) de C++.

Le comportement par défaut si aucune option n'est fournie est de suivre le standard, mais également d'autoriser (et d'émettre un avertissement pour) un code écrit dans l'ancien style qui serait autrement invalide, ou qui aurait un comportement différent.

-fno-gnu-keywords

Ne pas reconnaître « typeof » comme un mot-clé, afin que le code puisse utiliser ce mot comme identificateur. Vous pouvez utiliser le mot-clé « __typeof__ » à la place. -ansi implique -fno-gnu-keywords.

-fno-implicit-templates

Ne jamais émettre de code pour des modèles non en ligne (inline) qui sont instanciés implicitement (c.-à-d. par leur usage) ; n'émettre de code que pour les instanciations explicites.

-fno-implicit-inline-templates

Ne pas émettre de code pour des instanciations implicites de modèles en ligne. Le comportement par défaut est de traiter les inlines différemment de sorte que des compilations avec ou sans optimisation auront besoin du même ensemble d'instanciations implicites.

-fno-implement-inlines

Pour économiser de l'espace, ne pas émettre de copies hors ligne de fonctions inline contrôlées par #pragma implementation. Cela provoquera des erreurs lors de l'édition de liens si ces fonctions ne sont pas mises en ligne partout où elles sont appelées.

-fms-extensions

Désactiver les avertissements pédants sur les constructions utilisées dans les MFC (NdT : Microsoft Foundation Classes ?), comme le int implicite ou l'obtention d'un pointeur vers une fonction membre via une syntaxe non standard.

-fno-nonansi-builtins

Désactiver les déclarations intégrées de fonctions qui ne sont pas prévues par le C ANSI/ISO. Celles-ci incluent « ffs », « alloca », « _exit », « index », « bzero », « conjf », et d'autres fonctions associées.

-fno-operator-names

Ne pas traiter les mots-clés nom d'opérateur « and », « bitand », « bitor », « compl », « not », « or » et « xor » comme des synonymes pour les mots-clés.

-fno-optional-diags

Désactiver les messages de diagnostic pour lesquels le standard ne prévoit pas d'obligation d'émission de la part du compilateur. Actuellement, le seul diagnostic de ce type émis par G++ est celui d'un nom possédant de multiples significations à l'intérieur d'une classe.

-fpermissive

Rabaisser les messages sur du code non conforme d'erreurs en avertissements. Par défaut, G++ utilise effectivement -pedantic-errors sans -pedantic ; cette option renverse ce fait. Ce comportement et cette option sont surchargés par -pedantic, qui fonctionne de la même manière que dans le C GNU.

-frepo

Activer l'instanciation automatique de modèles. Cette option implique également -fno-implicit-templates.

-fno-rtti

Désactiver la génération d'informations sur chaque classe comprenant des fonctions virtuelles pour utilisation par les fonctionnalités d'identification de type à l'exécution de C++ (dynamic_cast et typeid). Si vous n'utilisez pas ces parties du langage, vous pouvez économiser de l'espace en utilisant cette option. Notez que le mécanisme de traitement des exceptions utilise les mêmes informations, mais il les générera en cas de besoin.

-fstats

Émettre des statistiques sur le traitement des frontaux à la fin de la compilation. Cette information n'est généralement utile qu'à l'équipe de développement de G++.

-ftemplate-depth-n

Fixer la profondeur d'instanciation maximale des classes modèles à n. Une limite sur la profondeur d'instanciation des modèles est nécessaire pour détecter des récursions infinies lors de l'instanciation de classes modèles. Les programmes conformes au C++ ANSI/ISO ne doivent pas compter sur une taille maximale supérieure à 17.

-fuse-cxa-atexit

Enregistrer les destructeurs d'objets ayant une durée de stockage statique avec la fonction « __cxa_atexit » plutôt qu'avec la fonction « atexit ». Cette option est requise pour avoir un comportement totalement conforme aux standards des destructeurs statiques, mais ne fonctionnera que si votre bibliothèque C supporte « __cxa_atexit ».

-fvtable-gc

Émettre des relogements spéciaux pour les références à des vtables ou à des fonctions virtuelles afin que l'éditeur de liens puisse identifier les fonctions virtuelles inutilisées et zéro-ifier les entrées de vtable qui s'y réfèrent. C'est utile principalement avec -ffunction-sections et -Wl,--gc-sections, pour également éliminer les fonctions elles-mêmes.

Cette optimisation requiert GNU as et GNU ld. Tous les systèmes ne supportent pas cette option. -Wl,--gc-sections est ignoré sans -static.

-fno-weak

Ne pas utiliser le support des symboles faibles, même s'il est fourni par l'éditeur de liens. Par défaut, G++ utilisera les symboles faibles s'ils sont disponibles. Cette option n'existe qu'à des fins de tests, et ne devrait pas être utilisée par les utilisateurs finaux ; elle résulte en un code moins bon et n'offre aucun avantage. Cette option pourrait être supprimée dans une future version de G++.

-nostdinc++

Ne pas rechercher de fichiers d'en-tête dans les répertoires standard spécifiques à C++, mais toujours effectuer une recherche dans les autres répertoires standard. (Cette option est utilisée pour compiler la bibliothèque C++.)

De plus, les options suivantes d'optimisation, d'avertissement et de génération de code n'ont de sens que pour les programmes C++:

-fno-default-inline

Ne pas supposer que les fonctions définies à l'intérieur de la portée d'une classe sont inline. Notez que ces fonctions auront une édition des liens similaire à celle des fonctions en ligne ; elles ne seront simplement pas mises en ligne par défaut.

-Wabi (C++ uniquement)

Avertir quand G++ génère du code probablement non compatible avec l'ABI C++ neutre vis-à-vis du vendeur. Bien qu'un effort ait été consenti pour alerter l'utilisateur dans de tels cas, il en subsiste probablement quelques uns qui ne sont pas détectés, et ce même si G++ génère du code incompatible. Il peut également y avoir des situations où des avertissements sont émis même si le code généré sera compatible.

Vous devriez réécrire votre code de sorte à éviter ces avertissements si vous vous inquiétez du fait que le code généré par G++ puisse ne pas être compatible au niveau binaire avec du code généré par d'autres compilateurs.

Les incompatibilités connues à ce jour incluent :

-Wctor-dtor-privacy (C++ uniquement)

Avertir quand une classe semble inutilisable, parce que tous les constructeurs ou destructeurs d'une classe sont privés, et que la classe n'a pas d'amies ou de fonctions membres publiques statiques.

-Wnon-virtual-dtor (C++ uniquement)

Avertir quand une classe déclare un destructeur non-virtuel qui devrait probablement être virtuel, car il semble que la classe sera utilisée de façon polymorphique.

-Wreorder (C++ uniquement)

Avertir quand l'ordre des initialiseurs de membres fournis dans le code ne correspond pas à l'ordre dans lequel ils doivent être exécutés. Par exemple :

        struct A {
          int i;
          int j;
          A(): j (0), i (1) { }
        };
    

Ici, le compilateur avertira que les initialiseurs de membres pour i et j seront réarrangés pour qu'ils correspondent à l'ordre de déclaration des membres.

Les options -W... suivantes ne sont pas entraînées par -Wall.

-Weffc++ (C++ uniquement)

Avertir des violations de directives de style suivantes provenant du livre Effective C++ de Scott Meyers :

-Wno-deprecated (C++ uniquement)

Ne pas avertir de l'utilisation de fonctionnalités dépréciées.

-Wno-non-template-friend (C++ uniquement)

Désactiver les avertissements quand des fonctions amies non transformées en modèle sont déclarées à l'intérieur d'un modèle. Avec l'apparition du support des spécifications de modèles explicites dans G++, si le nom de l'amie est un ID non qualifié (p.ex. friend foo(int)), la spécification du langage C++ demande que l'amie déclare ou définisse une fonction ordinaire, non modèle. (Section 14.5.3). Avant que G++ n'implémente les spécifications explicites, les IDs non qualifiés pouvaient être interprétés comme une spécialisation particulière d'une fonction transformée en modèle. Puisque ce comportement non conforme n'est à présent plus le comportement par défaut de G++, -Wnon-template-friend permet au compilateur de vérifier le code existant pour voir s'il ne recèle pas d'endroit à problème potentiel, et est activé par défaut. Ce nouveau comportement du compilateur peut être désactivé avec -Wno-non-template-friend qui garde un code de compilateur conforme, mais qui désactive l'avertissement utile.

-Wold-style-cast (C++ uniquement)

Avertir si un transtypage dans l'ancien style (style C) vers un type non-void est utilisé dans un programme C++. Les transtypages du nouveau style (static_cast, reinterpret_cast et const_cast) sont moins vulnérables à des effets inattendus, et beaucoup plus faciles à détecter.

-Woverloaded-virtual (C++ uniquement)

Avertir quand une déclaration de fonction masque les fonctions virtuelles d'une classe de base. Exemple :

        struct A {
          virtual void f();
        };
    

        struct B: public A {
          void f(int);
        };
    

Ici, la version de « f » de la classe « A » est cachée par celle de « B », et la compilation d'un code comme

        B* b;
        b->f();
    

échouera.

-Wno-pmf-conversions (C++ uniquement)

Désactiver le diagnostic généré lors de la conversion d'un pointeur borné vers une fonction membre en un pointeur simple.

-Wsign-promo (C++ uniquement)

Avertir quand une résolution de surcharge choisit une promotion d'un type non signé ou énuméré vers un type signé au lieu d'une conversion vers un type non signé de la même taille. Les versions précédentes de G++ essayaient de préserver le caractère non signé, mais le standard impose le comportement actuel.

-Wsynth (C++ uniquement)

Avertir quand le comportement de synthèse de G++ ne correspond pas à celui de cfront. Par nexemple :

        struct A {
          operator int ();
          A& operator = (int);
        };
    

        main ()
        {
          A a,b;
          a = b;
        }
    

Dans cet exemple, G++ synthétisera un A& operator = (const A&); par défaut, alors que cfront utilisera l'operator = défini par l'utilisateur.

Options contrôlant le dialecte Objective-C

Cette section décrit les options de ligne de commandes qui ne sont significatives que pour les programmes Objective-C ; mais vous pouvez également utiliser la plupart des des options du compilateur GNU quel que soit le langage dans lequel votre programme est écrit. Par exemple, vous pourriez compiler un fichier « une_classe.m » comme ceci :

        gcc -g -fgnu-runtime -O -c une_classe.m

Voici une liste des options qui sont disponibles uniquement lors de la compilation de programmes Objective-C :

-fconstant-string-class=nom-classe

Utiliser nom-classe en tant que nom de classe à instancier pour chaque chaîne de caractères littérale spécifiée avec la syntaxe « @"..." ». Le nom de classe par défaut est « NXConstantString ».

-fgnu-runtime

Générer un code objet compatible avec l'environnement d'exécution standard GNU d'Objective-C. C'est le comportement par défaut sur la plupart des types de systèmes.

-fnext-runtime

Générer une sortie compatible avec l'environnement d'exécution NeXT. C'est le comportement par défaut sur les systèmes basés sur NeXT, ce qui inclut Darwin et Mac OS X.

-gen-decls

Décharger (dump) les déclarations d'interface pour toutes les classes rencontrées dans le fichier source dans un fichier nommé nom-source.decl.

-Wno-protocol

Ne pas avertir si des méthodes requises par un protocole ne sont pas implémentées dans la classe l'adoptant.

-Wselector

Avertir si un sélecteur possède des définitions de multiples méthodes de différents types.

Options pour contrôler le formatage des messages de diagnostic

Traditionnellement, les messages de diagnostic ont été formatés sans se soucier de l'aspect du périphérique de sortie (p.ex. sa largeur, ...). Les options décrites plus bas peuvent être utilisées pour contrôler l'algorithme de formatage des messages de diagnostic, p.ex. le nombre de caractères pas ligne, ou à quelle fréquence les informations de localisation doivent être rapportées. Actuellement, seul le frontal C++ peut respecter ces options. Néanmoins, il est prévu que les autres frontaux supportent ces options dans un futur proche.

-fmessage-length=n

Essayer de formater les messages d'erreur de sorte qu'ils conviennent à des lignes d'environ n caractères. La valeur par défaut est de 72 caractères pour g++, et 0 pour les autres frontaux supportés par GCC. Si n vaut zéro, aucun découpage en lignes ne sera effectué ; chaque message d'erreur apparaîtra sur une seule ligne.

-fdiagnostics-show-location=once

Significatif uniquement dans le mode de césure de lignes. Indique au rapporteur de messages de diagnostic d'émettre une seule fois les informations de localisation de la source ; c.-à-d. que si le message est trop long pour convenir sur une seule ligne physique et doit être découpé, la localisation de la source ne sera pas réémise (comme préfixe) dans toutes les lignes de prolongement consécutives. C'est le comportement par défaut.

-fdiagnostics-show-location=every-line

Significatif uniquement dans le mode de césure de lignes. Indique au rapporteur de messages de diagnostic d'émettre les mêmes informations de localisation de la source (comme préfixe) pour les lignes physiques qui résultent du processus de découpage d'un message trop long pour tenir sur une seule ligne.

Options pour requérir ou supprimer des avertissements

Les avertissements sont des messages de diagnostic qui rapportent des constructions qui ne sont pas intrinsèquement erronés, mais qui sont risquées ou qui suggèrent qu'il y ait pu avoir une erreur.

Vous pouvez requérir de nombreux avertissements spécifiques grâce aux options commençant par -W, comme par exemple -Wimplicit pour requérir des avertissements sur les déclarations implicites. Chacune de ces options d'avertissement spécifiques a également une forme négative commençant par -Wno- pour désactiver les avertissements ; par exemple, -Wno-implicit. Ce manuel ne liste que l'une de ces deux formes, en l'occurrence celle qui n'est pas activée par défaut.

Les options suivantes contrôlent la quantité et le type d'avertissements produits par GCC ; pour plus d'options spécifiques au langage, référez-vous également à @ref{C++ Dialect Options} et @ref{Objective-C Dialect Options}.

-fsyntax-only

Vérifier le code pour détecter des erreurs de syntaxe, mais ne rien faire d'autre.

-pedantic

Émettre tous les avertissement demandés par le standard C ISO et C++ ISO ; rejeter tous les programmes qui utilisent des extensions interdites, et d'autres programmes qui ne suivent pas le C ISO ou le C++ ISO. Pour le C ISO, suivre la version du standard C ISO spécifiée par une option -std.

Les programmes C ISO et C++ ISO valides devraient être compilés correctement avec ou sans cette option (bien qu'un petit nombre d'entre eux requerront -ansi ou une option -std spécifiant la version du C ISO requise). Néanmoins, sans cette option, certaines extensions GNU et fonctionnalités du C et du C++ sont tout de même supportées. Sans cette option, elles sont rejetées.

-pedantic ne génère pas de message d'avertissement lors de l'utilisation de mots-clés alternatifs dont le nom commence et se termine par __. Les avertissements pédants sont également désactivés dans l'expression qui suit « __extension__ ». Néanmoins, seuls les fichiers d'en-tête système devraient utiliser ces chemins détournés ; les programmes applicatifs devraient les éviter.

Certains utilisateurs essaient d'utiliser -pedantic pour vérifier la conformité stricte de programmes au C ISO. Ils se rendront compte tôt ou tard que cette option ne fait pas exactement ce qu'ils veulent : elle détecte certaines pratiques non-ISO, mais pas toutes -- uniquement celles pour lesquelles le C ISO requiert un diagnostic, et certaines autres pour lesquels des diagnostics ont été ajoutés.

Une fonctionnalité de rapport de toute violation au C ISO pourrait parfois être utile, mais requerrait un travail additionnel considérable, et serait très différente de -pedantic. Nous n'avons pas l'intention de supporter une telle fonctionnalité dans l'immédiat.

Là où le standard spécifié par -std représente un dialecte C étendu par GNU, comme gnu89 ou gnu99, il y a un standard de base correspondant, la version de C ISO C sur laquelle est basée le dialecte étendu par GNU. Les avertissements de -pedantic sont fournis là où ils sont requis par le standard de base. (Il serait illogique que de tels avertissements ne soient fournis que pour des fonctionnalités non présentes dans le dialecte C GNU, puisque la définition des dialectes GNU du C inclut toutes les fonctionnalités que le compilateur supporte avec l'option fournie, et il ne serait pas nécessaire de l'indiquer.)

-pedantic-errors

Comme -pedantic, sauf que des erreurs sont produites plutôt que des avertissements.

-w

Inhiber tous les messages d'avertissement.

-Wno-import

Inhiber tous les messages d'avertissement concernant l'utilisation de #import.

-Wchar-subscripts

Avertir si un indice de tableau est du type « char ». C'est une cause fréquente d'erreur puisque les programmeurs oublient souvent que ce type est signé sur certaines machines.

-Wcomment

Avertir quand une séquence de début de commentaire /* apparaît dans un commentaire /*, ou chaque fois qu'un backslash suivi d'un saut de ligne apparaît dans un commentaire //.

-Wformat

Contrôler les appels à « printf » et « scanf », etc., pour s'assurer que les arguments fournis ont des types appropriés à la chaîne de format spécifiée, et que les conversions spécifiées dans la chaîne de format ont du sens. Cela inclut les fonctions standard, et d'autres spécifiées par les attributs de format dans les familles « printf », « scanf », « strftime » et « strfmon » (une extension X/Open, non présente dans le C standard).

Les formats sont comparés avec les fonctionnalités de format supportées par la libc GNU version 2.2. Celles-ci incluent toutes les fonctionnalités de C89 et C99 ISO, en plus des fonctionnalités de la Single Unix Specification et de certaines extensions BSD et GNU. D'autres implémentations de bibliothèque peuvent ne pas supporter toutes ces fonctionnalités ; GCC ne supporte pas les avertissements pour des fonctionnalités dépassant les limitations d'une bibliothèque particulière. Néanmoins, si -pedantic est utilisé avec -Wformat, des avertissements seront fournis pour des fonctionnalités de format non présentes dans la version du standard sélectionnée (mais pas pour les formats « strfmon », puisque ceux-ci ne font partie d'aucune version du C standard).

-Wformat est inclus dans -Wall. Pour obtenir plus de contrôle sur certains aspects de la vérification de format, les options -Wno-format-y2k, -Wno-format-extra-args, -Wformat-nonliteral, -Wformat-security et -Wformat=2 sont disponibles, mais ne sont pas incluses dans -Wall.

-Wno-format-y2k

Si -Wformat est spécifié, ne pas avertir de l'utilisation de formats « strftime » qui peuvent produire une année à deux chiffres.

-Wno-format-extra-args

Si -Wformat est spécifié, ne pas avertir de la présence d'arguments en excès lors d'un appel à une fonction de formatage « printf » ou « scanf ». Le standard C spécifie que de tels arguments sont ignorés.

Là où les arguments inutilisés résident entre les arguments utilisés qui sont spécifiés avec des spécifications de numéro d'opérande $, des avertissements sont normalement toujours fournis, puisque l'implémentation ne pouvait savoir quel type passer à « va_arg » pour sauter les arguments inutilisés. Néanmoins, dans le cas des formats de « scanf », cette option supprimera l'avertissement si les arguments inutilisés sont tous des pointeurs, car la Single Unix Specification dit que de tels arguments non utilisés sont autorisés.

-Wformat-nonliteral

Si -Wformat est spécifié, avertir également si la chaîne de caractères de format n'est pas une chaîne littérale et ne peut être vérifiée, à moins que la fonction de format ne prenne ses arguments de format dans une « va_list ».

-Wformat-security

Si -Wformat est spécifié, avertir également de l'utilisation de fonctions de format qui représentent des problèmes de sécurité potentiels. À l'heure actuelle, cela avertit des appels aux fonctions « printf » et « scanf » où la chaîne de caractères de format n'est pas une chaîne littérale et où il n'y a pas d'arguments de format, comme dans « printf (foo); ». Cela pourrait être un trou de sécurité si la chaîne de caractères de format provient d'une entrée non de confiance et contient %n. (C'est actuellement un sur-ensemble de ce qu'avertit -Wformat-nonliteral mais, dans le futur, des avertissements pourraient être ajoutés à -Wformat-security qui ne sont pas inclus dans -Wformat-nonliteral.)

-Wformat=2

Activer -Wformat plus des vérifications de format non incluses dans -Wformat. Actuellement équivalent à -Wformat -Wformat-nonliteral -Wformat-security.

-Wimplicit-int

Avertir chaque fois qu'une déclaration ne spécifie pas de type.

-Wimplicit-function-declaration

-Werror-implicit-function-declaration

Fournir un avertissement (une erreur) chaque fois qu'une fonction est utilisée avant d'être déclarée.

-Wimplicit

Similaire à -Wimplicit-int et -Wimplicit-function-declaration.

-Wmain

Avertir si le type de main est suspicieux. main devrait être une fonction avec une liaison externe, renvoyant un int, prenant zéro, deux ou trois arguments de types appropriés.

-Wmissing-braces

Avertir si un initialiseur d'agrégat ou d'union n'est pas entièrement parenthésé. Dans l'exemple suivant, l'initialiseur de a n'est pas entièrement parenthésé, mais celui de b l'est.

        int a[2][2] = { 0, 1, 2, 3 };
        int b[2][2] = { { 0, 1 }, { 2, 3 } };
    

-Wparentheses

Avertir si des parenthèses sont omises dans certains contextes, comme par exemple quand il y a une affectation dans un contexte où l'on s'attend à une valeur de vérité, ou quand les opérateurs sont imbriqués (ou lorsque des opérateurs dont la priorité provoque souvent le trouble dans l'esprit des gens sont imbriqués).

Avertir également des constructions où il pourrait y avoir une ambiguïté pour savoir à quelle instruction « if » correspond une branche « else ». Voici un exemple d'un tel cas :

        {
          if (a)
            if (b)
              foo ();
          else
            bar ();
        }
    

En C, chaque branche « else » appartient à l'instruction « if » la plus interne ce qui, dans cet exemple, est « if (b) ». Ce n'est souvent pas ce à quoi s'attendait le programmeur, comme illustré dans l'exemple ci-dessus par l'indentation qu'a choisi le programmeur. Quand il y a un risque d'une telle ambiguïté, GCC émettra un avertissement quand ce drapeau est spécifié. Pour éliminer cet avertissement, ajoutez des accolades explicites autour de l'instruction « if » la plus interne de sorte qu'il n'y ait aucune possibilité que le « else » appartienne au « if » entourant. Le code résultant ressemblerait à ceci :

        {
          if (a)
            {
              if (b)
                foo ();
              else
                bar ();
            }
        }
    

-Wsequence-point

Avertir de code pouvant posséder une sémantique indéfinie à cause de violations des règles de points de séquence du C standard.

Le standard C définit l'ordre dans lequel les expressions d'un programme C sont évaluées en terme de points de séquence, qui représentent un ordre partiel entre l'exécution de parties du programme : celles exécutées avant le point de séquence, et celles exécutées après. Celles-ci se produisent après l'évaluation d'une expression complète (c.-à-d. ne faisant pas partie d'une autre expression), après l'évaluation du premier opérande d'un opérateur « && », « ⎪⎪ », « ? : » ou « , » (virgule), avant qu'une fonction ne soit appelée (mais après l'évaluation de ses arguments et de l'expression dénotant la fonction appelée), et à certains autres endroits. Mis à part via les règles de points de séquence, l'ordre d'évaluation des sous-expressions d'une expression n'est pas spécifié. Toutes ces règles ne décrivent qu'un ordre partiel plutôt qu'un ordre total puisque, par exemple, si deux fonctions sont appelées dans une expression sans le moindre point de séquence entre elles, l'ordre dans lequel les fonctions sont appelées n'est pas spécifié. Néanmoins, le comité du standard a formulé la règle selon laquelle les appels de fonctions ne se superposent pas.

Il n'est pas spécifié quand les modifications apportées aux valeurs des objets ont lieu entre les points de séquence. Les programmes dont le comportement dépend de ceci ont un comportement indéfini ; le standard C spécifie que « Entre le point de séquence précédent et le suivant, un objet verra sa valeur stockée modifiée au plus une fois lors de l'évaluation d'une expression. De plus, la valeur précédente ne sera lue que pour déterminer la valeur à stocker. Si un programme ne respecte pas ces règles, les résultats sur une implémentation particulière sont entièrement imprévisibles.

Des exemple de code au comportement non défini sont « a = a++; », « a[n] = b[n++] » et « a[i++] = i; ». Certains cas plus compliqués ne sont pas diagnostiqués par cette option, et elle peut parfois fournir un résultat faussement positif, mais elle est en général assez efficace pour détecter ce type de problème dans des programmes.

L'implémentation actuelle de cette option ne fonctionne que pour les programmes C. Une future implémentation pourrait également fonctionner pour les programmes C++.

Le standard C est formulé de façon confuse, et il subsiste par conséquent quelque débat portant sur la signification précise des règles de points de séquence dans des cas subtils. Des liens vers des discussions sur le problème, incluant des propositions de définitions formelles, peuvent être trouvés dans notre page de lectures, sur <http://gcc.gnu.org/readings.html>.

-Wreturn-type

Avertir chaque fois qu'une fonction est définie avec un type de retour qui est « int » par défaut. Avertir également de toute instruction « return » ne retournant aucune valeur dans une fonction dont le type de retour n'est pas « void ».

Pour le C++, une fonction sans type de retour produit toujours un message de diagnostic, même si -Wno-return-type est spécifié. Les seules exceptions sont main et les fonctions définies dans les fichiers d'en-tête système.

-Wswitch

Avertir chaque fois qu'une instruction « switch » a un index de type énuméré auquel manque un « case » pour un ou plusieurs des codes nommés de cette énumération. (La présence d'une étiquette « default » empêche la génération de cet avertissement.) Les étiquettes « case » en dehors de la portée de l'énumération provoquent aussi des avertissements quand cette option est utilisée.

-Wtrigraphs

Avertir quand un trigraphe est rencontré qui pourrait changer la signification du programme (les trigraphes à l'intérieur de commentaires ne sont pas pris en compte).

-Wunused-function

Avertir chaque fois qu'une fonction statique est déclarée mais non définie ou qu'une fonction statique non inline est inutilisée.

-Wunused-label

Avertir chaque fois qu'une étiquette est déclarée mais pas utilisée.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-parameter

Avertir chaque fois qu'un paramètre de fonction n'est pas utilisé si ce n'est dans sa déclaration.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-variable

Avertir chaque fois qu'une variable locale ou qu'une variable statique non constante n'est pas utilisée ailleurs que dans sa déclaration.

Pour supprimer cet avertissement, utilisez l'attribut unused.

-Wunused-value

Avertir chaque fois qu'une instruction calcule un résultat qui n'est pas explicitement utilisé.

Pour supprimer cet avertissement, transtypez l'expression vers void.

-Wunused

Toutes les options -Wunused ci-dessus combinées.

Pour obtenir un avertissement sur un paramètre de fonction inutilisé, vous devez spécifier soit -W -Wunused, soit -Wunused-parameter.

-Wuninitialized

Avertir si une variable automatique est utilisée sans avoir été initialisée au préalable, ou si une variable peut être corrompue par un appel à « setjmp ».

Ces avertissements sont possibles uniquement en cas de compilation optimisante, car ils requièrent de l'information sur le flux de données qui est calculée uniquement dans la compilation optimisante. Si vous ne spécifiez pas -O, vous n'obtiendrez tout simplement pas ces avertissements.

Ces avertissements se produisent uniquement pour les variables qui sont candidates à une allocation dans un registre. Donc, ils ne se produisent pas pour une variable déclarée « volatile », ou dont on emploie l'adresse, ou dont la taille est différente de 1, 2, 1 ou 8 octets. Ils ne sont également pas générés pour des structures, unions ou tableaux, même s'ils sont dans des registres.

Notez qu'il peut ne pas y avoir d'avertissement au sujet d'une variable qui est utilisée uniquement pour calculer une valeur qui n'est elle-même jamais utilisée, car de tels calculs peuvent être supprimés par l'analyse du flux de données avant que les avertissements ne soient affichés.

Ces avertissements ont été rendus optionnels car GCC n'est pas assez intelligent pour détecter toutes les raisons qui pourraient pousser un code à être correct en dépit de l'apparence de contenir une erreur. Voici un exemple de la façon dont cela peut se produire :

        {
          int x;
          switch (y)
            {
            case 1: x = 1;
              break;
            case 2: x = 4;
              break;
            case 3: x = 5;
            }
          foo (x);
        }
    

Si la valeur de « y » est toujours 1, 2 ou 3, alors « x » est toujours initialisé, mais GCC ne sait pas cela. Voici un autre cas courant :

        {
          int save_y;
          if (change_y) save_y = y, y = new_y;
          ...
          if (change_y) y = save_y;
        }
    

Ceci ne comporte pas de bogue car « save_y » n'est utilisé que s'il est préalablement initialisé.

Cette option avertit également quand une variable automatique non volatile pourrait être modifiée par un appel à « longjmp ». Ces avertissements ne sont également possibles qu'en cas de compilation optimisante.

Le compilateur ne voit que les appels à « setjmp ». Il ne peut savoir où « longjmp » sera appelé ; en fait, un gestionnaire de signaux pourrait l'appeler n'importe où dans le code. Vous pourriez donc obtenir un avertissement alors même qu'il n'y a aucun problème car « longjmp » ne peut en fait être appelé à l'endroit qui causerait un problème.

Certains faux avertissements peuvent être évités si vous déclarez toutes les fonctions que vous utilisez et qui ne retournent jamais à l'appelant comme étant « noreturn ».

-Wreorder (C++ uniquement)

Avertir quand l'ordre des initialiseurs de membres dans le code ne correspond pas à l'ordre dans lequel ils doivent être exécutés.

-Wunknown-pragmas

Avertir quand GCC rencontre une directive #pragma qu'il ne comprend pas. Si cette option de ligne de commandes est utilisée, des avertissements seront émis même pour des pragmas inconnus dans les fichiers d'en-tête système. Ce n'est pas le cas si les avertissements avaient été activés uniquement via l'option de ligne de commande -Wall.

-Wall

Toutes les options -W ci-dessus combinées. Cela active tous les avertissements sur des constructions que certains utilisateurs trouvent contestables, et qui sont faciles à éviter (ou à modifier pour éviter cet avertissement), même en conjonction avec des macros.

-Wdiv-by-zero

Avertir lors d'une division entière par zéro lors de la compilation. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-div-by-zero. La division flottante par zéro ne fait pas l'objet d'un avertissement, car cela peut être une façon légitime d'obtenir des infinis et des NaNs (Not A Number, non-nombres).

-Wmultichar

Avertir quand une constante multi-caractères ('FOOF') est utilisée. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-multichar. Normalement, cela indique une faute de frappe dans le code de l'utilisateur, car elles ont des valeurs définies par l'implémentation, et ne devraient pas être utilisées dans un code portable.

-Wsystem-headers

Afficher des messages d'avertissement pour des constructions trouvées dans les fichiers d'en-tête système. Les avertissements provenant des fichiers d'en-tête système sont normalement supprimés, en prenant l'hypothèse qu'ils n'indiquent généralement pas des problèmes réels et qu'ils ne feraient que rendre la sortie du compilateur plus difficile à lire. L'utilisation de cette option de ligne de commandes indique à GCC d'émettre des avertissements provenant des fichiers d'en-tête système comme s'ils se produisaient en mode utilisateur. Néanmoins, notez que l'utilisation de -Wall avec cette option n'avertira pas des pragmas inconnus dans les en-têtes système -- pour cela, -Wunknown-pragmas doit également être utilisé.

Les options -W... suivantes ne sont pas impliquées par -Wall. Certaines d'entre elles avertissent de constructions que les utilisateurs ne considèrent généralement pas être discutables, mais dont ils aimeraient être informés ; d'autres avertissent de constructions qui sont nécessaires ou difficiles à éviter dans certains cas, et pour lesquelles il n'existe pas d'alternative simple permettant de supprimer cet avertissement.

-W

Afficher des messages d'avertissement supplémentaires pour les événements suivants :

-Wfloat-equal

Avertir si des valeurs flottantes sont utilisées lors de comparaisons d'égalité.

L'idée derrière ceci est qu'il est parfois commode (pour le programmeur) de considérer des valeurs flottantes comme étant des approximations de nombres réels de précision infinie. Si vous faites cela, alors vous devez calculer (en analysant le code, ou par un autre moyen) l'erreur supposée maximale qu'introduit le calcul, et l'autoriser quand vous effectuez des comparaisons (et quand vous produisez une sortie, mais c'est un problème différent). En particulier, au lieu de tester l'égalité, vous devriez vérifier si les deux valeurs ont des portées qui se chevauchent ; et cela est effectué en utilisant les opérateurs relationnels, car les comparaisons d'égalité ont de fortes chances de se tromper.

-Wtraditional (C uniquement)

Avertir de certaines constructions qui se comportent différemment en C traditionnel et en C ISO. Avertir également des constructions C ISO qui n'ont pas d'équivalent en C traditionnel, et/ou des constructions problématiques qui devraient être évitées.

-Wundef

Avertir si un identificateur non défini est évalué dans une directive #if.

-Wshadow

Avertir chaque fois qu'une variable locale masque une autre variable locale, un paramètre ou une variable globale, ou chaque fois qu'une fonction intégrée est masquée.

-Wlarger-than-longueur

Avertir chaque fois qu'un objet de plus de longueur octets est défini.

-Wpointer-arith

Avertir de tout ce qui dépend de la « taille » d'un type fonction ou de « void ». GNU C donne à ces types une taille de 1, pour sa propre convenance, dans les calculs mettant en jeu des pointeurs « void * » et des pointeurs vers des fonctions.

-Wbad-function-cast (C uniquement)

Avertir à chaque fois qu'un appel de fonction est transtypé vers un type non compatible. Par exemple, avertir si « int malloc() » est transtypé vers « nimportequoi * ».

-Wcast-qual

Avertir chaque fois qu'un pointeur est transtypé afin de supprimer un qualificateur de type du type de la cible. Par exemple, avertir si un « const char * » est transtypé vers un « char * » ordinaire.

-Wcast-align

Avertir chaque fois qu'un pointeur est transtypé d'une façon telle que l'alignement de la cible est augmenté. Par exemple, avertir si un « char * » est transtypé vers un « int * » sur des machines où les entiers peuvent uniquement être accédés à des limites de deux ou quatre octets.

-Wwrite-strings

Lors de la compilation de code C, donner aux chaînes de caractères constantes le type « const char[longueur] » de sorte que la copie de l'adresse d'une de celles-ci dans un pointeur non-« const char * » engendrera un avertissement ; lors de la compilation de code C++, avertir si la conversion dépréciée de constante de type chaîne de caractères vers « char * » est utilisée. Ces avertissements vous aideront à détecter au moment de la compilation du code qui tente d'écrire dans une chaîne de caractères constante, mais uniquement si vous avez été très attentif en utilisant « const » dans les déclarations et les prototypes. Sinon, cela ne pourrait qu'être nuisible ; voilà pourquoi nous n'avons pas inclus ces avertissements dans -Wall.

-Wconversion

Avertir si un prototype provoque une conversion de types qui est différente de ce qui arriverait au même argument en l'absence de prototype. Ceci inclut les conversions de valeurs à virgule fixe (fixed point) en valeurs à virgule flottante et vice-versa, et les conversions modifiant la largeur ou le signe d'un argument à virgule fixe sauf quand elles sont identiques à la promotion par défaut.

Avertir également si une expression constante entière négative est implicitement convertie vers un type non signé. Par exemple, avertir à propos de l'affectation « x = -1 » si « x » est non signé. Mais ne pas avertir des transtypages explicites comme p.ex. « (unsigned) -1 ».

-Wsign-compare

Avertir quand une comparaison entre valeurs signées et non signées pourrait produire un résultat incorrect lorsque la valeur signée est convertie en non signé. Cet avertissement est également activé par -W ; pour obtenir les autres avertissements de -W sans cet avertissement, utilisez -W -Wno-sign-compare.

-Waggregate-return

Avertir si une fonction renvoyant des structures ou des unions sont définies ou appelées. (Dans les langages où l'on peut renvoyer des tableaux, cela provoque également un avertissement)

-Wstrict-prototypes (C uniquement)

Avertir si une fonction est déclarée ou définie sans que le type des arguments ne soit spécifié. (Une définition de fonction écrite dans l'ancien style est permise sans avertissement si elle est précédée par une déclaration qui spécifie le type des arguments.)

-Wmissing-prototypes (C uniquement)

Avertir si une fonction globale est définie sans déclaration de prototype préalable. Cet avertissement est émis même si la définition elle-même fournit un prototype. Le but est de détecter les fonctions globales qui ne sont pas déclarées dans des fichiers d'en-tête.

-Wmissing-declarations

Avertir si une fonction globale est définie sans déclaration préalable. Faire cela même si la définition fournit elle-même un prototype. Utilisez cette option pour détecter les fonctions globales qui ne sont pas déclarées dans des fichiers d'en-tête.

-Wmissing-noreturn

Avertir de l'existence de fonctions pouvant être candidates à l'attribut « noreturn ». Notez que celles-ci ne sont que des candidates possibles, et pas des candidates absolues. Il faut faire attention à vérifier manuellement que les fonctions ne retournent jamais à l'appelant avant d'ajouter l'attribut « noreturn », car sinon des bogues de génération de code subtils pourraient être introduits. Vous n'obtiendrez pas d'avertissement pour « main » dans les environnements C hôtes.

-Wmissing-format-attribute

Si -Wformat est activé, avertir également des fonctions pouvant être candidates à l'attribut « format ». Notez que celles-ci ne sont que des candidates possibles, et pas des candidates absolues. GCC devinera que les attributs « format » peuvent être appropriés pour toute fonction qui appelle une fonction telle que « vprintf » ou « vscanf », mais cela pourrait ne pas toujours être le cas, et certaines fonctions pour lesquelles les attributs « format » sont appropriés peuvent ne pas être détectées. Cette option n'a aucun effet à moins que -Wformat ne soit activée (éventuellement par -Wall).

-Wno-deprecated-declarations

Ne pas avertir de l'utilisation de fonctions, variables et types marqués comme étant dépréciés en utilisant l'attribut « deprecated ». (@pxref{Function Attributes}, @pxref{Variable Attributes}, @pxref{Type Attributes}.)

-Wpacked

Avertir si une structure possède l'attribut « packed », mais l'attribut packed n'a aucun effet sur l'agencement ou la taille de la structure. De telles structures peuvent être mal alignées pour un petit avantage. Par exemple, dans ce code, la variable « f.x » dans « struct bar » sera mal alignée même si « struct bar » ne possède pas lui-même l'attribut packed :

        struct foo {
          int x;
          char a, b, c, d;
        } __attribute__((packed));
        struct bar {
          char z;
          struct foo f;
        };
    

-Wpadded

Avertir si du bourrage est inclus dans une structure, soit pour aligner un élément de la structure, soit pour aligner la structure toute entière. Parfois, quand cela arrive, il est possible de réarranger les champs de la structure afin de réduire le bourrage et de rapetisser la structure.

-Wredundant-decls

Avertir si quoi que ce soit est déclaré plus d'une fois dans la même portée, même dans les cas où une déclaration multiple est valide et ne change rien.

-Wnested-externs (C uniquement)

Avertir si une déclaration « extern » est rencontrée à l'intérieur d'une fonction.

-Wunreachable-code

Avertir si le compilateur détecte du code qui ne sera jamais exécuté.

Cette option est destinée à avertir l'utilisateur quand le compilateur détecte au moins une ligne entière de code qui ne sera jamais exécutée, car une certaine condition n'est jamais satisfaite ou parce qu'elle est située après une fonction qui ne revient jamais.

Il est possible que cette option produise un avertissement même s'il y a des circonstances dans lesquelles une partie de la ligne en question peut être exécutée, et il faut donc faire attention avant de supprimer du code apparemment inaccessible.

Par exemple, quand une fonction est en ligne, un avertissement peut signifier que la ligne est inaccessible dans au moins une copie en ligne de la fonction.

Cette option ne fait pas partie de -Wall car dans une version de débogage d'un programme, il y a souvent un code substantiel de vérification du fonctionnement correct du programme et qui est, si tout va bien, inaccessible car le programme fonctionne correctement. Un autre cas d'utilisation habituel de code inaccessible est de fournir un comportement qui est sélectionnable au moment de la compilation.

-Winline

Avertir quand une fonction ne peut pas être placée en ligne alors qu'elle a été déclarée inline.

-Wlong-long

Avertir si le type long long est utilisé. C'est le comportement par défaut. Pour inhiber les messages d'avertissement, utilisez -Wno-long-long. Les drapeaux -Wlong-long et -Wno-long-long sont pris en compte uniquement quand le drapeau -pedantic est utilisé.

-Wdisabled-optimization

Avertir si une passe d'optimisation requise est désactivée. Cet avertissement n'indique généralement pas qu'il y ait quelque chose d'anormal dans votre code ; il indique simplement que les optimiseurs de GCC n'ont pas été capables de traiter le code correctement. Souvent, le problème vient du fait que votre code est trop gros ou trop complexe ; GCC refusera d'optimiser des programmes quand l'optimisation elle-même est susceptible de prendre un temps excessif.

-Werror

Traiter les avertissements comme des erreurs.

Options pour déboguer votre programme ou GCC

GCC possède diverses options spéciales qui sont utilisées pour déboguer soit votre programme, soit GCC :

-g

Produire des informations de débogage dans le format natif du système d'exploitation (stabs, COFF, XCOFF, ou DWARF). GDB peut manipuler ces informations de débogage.

Sur la plupart des systèmes utilisant le format stabs, -g autorise l'utilisation d'informations de débogage supplémentaires que seul GDB peut utiliser ; ces informations supplémentaires améliorent le débogage avec GDB mais vont probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme. Si vous voulez contrôler avec certitude s'il faut générer des informations supplémentaires, utilisez -gstabs+, -gstabs, -gxcoff+, -gxcoff, -gdwarf-1+, -gdwarf-1 ou -gvms (voir plus bas).

À la différence de la plupart des autres compilateurs C, GCC vous permet d'utiliser -g avec -O. Les raccourcis empruntés par du code optimisé peuvent occasionnellement produire des résultats surprenants : certaines variables que vous aviez déclarées peuvent ne plus exister du tout ; le flux de contrôle peut brièvement se déplacer à un endroit inattendu, quelques instructions peuvent ne pas être exécutées car elles calculent des résultats de constantes ou leurs valeurs étaient déjà à portée de main ; quelques instructions peuvent s'exécuter dans des endroits différents car elles ont été déplacées hors de boucles.

Néanmoins, cela prouve qu'il est possible de déboguer une sortie optimisée. Cela rend possible l'usage de l'optimiseur pour des programmes qui peuvent êtres bogués.

Les options suivantes sont utiles quand GCC est généré avec la capacité de traiter plus d'un format de débogage.

-ggdb

Produire des informations de débogage destinées à être utilisées par GDB. Cela signifie qu'il faut utiliser le format le plus expressif disponible (DWARF 2, stabs, ou le format natif si aucun des deux n'est supporté), en incluant si possible les extensions GDB.

-gstabs

Produire des informations de débogage dans le format stabs (s'il est supporté) sans extension GDB. C'est le format utilisé par DBX sur la plupart des systèmes BSD. Sur les systèmes MIPS, Alpha et System V Release 4, cette option produit une sortie de débogage au format stabs qui n'est pas comprise par DBX ou SDB. Sur les systèmes System V Release 4, cette option requiert l'assembleur GNU.

-gstabs+

Produire des informations de débogage dans le format stabs (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme.

-gcoff

Produire des informations de débogage dans le format COFF (s'il est supporté). C'est le format utilisé par SDB sur la plupart des systèmes System V antérieurs à System V Release 4.

-gxcoff

Produire des informations de débogage dans le format XCOFF (s'il est supporté). C'est le format utilisé par le débogueur DBX sur les systèmes IBM RS/6000.

-gxcoff+

Produire des informations de débogage dans le format XCOFF (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme, et peut provoquer l'échec sur erreur des assembleurs différents de l'assembleur GNU (GAS)

-gdwarf

Produire des informations de débogage dans le format DWARF version 1 (s'il est supporté). C'est le format utilisé par SDB sur la plupart des systèmes System V Release 4.

-gdwarf+

Produire des informations de débogage dans le format DWARF version 1 (s'il est supporté), en utilisant les extensions GNU comprises uniquement par le débogueur GNU (GDB). L'utilisation de ces extensions va probablement faire crasher les autres débogueurs, ou leur faire refuser de lire le programme.

-gdwarf-2

Produire des informations de débogage dans le format DWARF version 2 (s'il est supporté). C'est le format utilisé par DBX sur IRIX 6.

-gvms

Produire des informations de débogage dans le format VMS (s'il est supporté). C'est le format utilisé par DEBUG sur les systèmes VMS.

-gniveau

-ggdbniveau

-gstabsniveau

-gcoffniveau

-gxcoffniveau

-gvmsniveau

Requérir de l'information de débogage et utiliser également niveau pour spécifier le niveau d'information requis. Le niveau par défaut est 2.

Le niveau 1 produit un minimum d'informations, suffisantes pour créer des piles d'appels (backtraces) dans des parties du programme que vous n'avez pas l'intention de déboguer. Ceci inclut les descriptions des fonctions et des variables externes, mais aucune information sur les variables locales ni sur les numéros de ligne.

Le niveau 3 inclut des informations supplémentaires, telles que les définitions de macros présentes dans le programme. Certains débogueurs supportent le développement des macros quand vous utilisez -g3.

Notez qu'afin d'éviter une confusion entre DWARF1 niveau de débogage 2 et DWARF2, ni -gdwarf ni -gdwarf-2 n'acceptent un niveau de débogage concaténé. Utilisez à la place une option -gniveau additionnelle pour changer le niveau de débogage pour DWARF1 ou DWARF2.

-p

Générer du code supplémentaire pour écrire des informations de profilage convenant au programme d'analyse « prof ». Vous devez utiliser cette option quand vous compilez les fichiers sources pour lesquels vous voulez obtenir des données, et vous devez également l'utiliser lors de l'édition des liens.

-pg

Générer du code supplémentaire pour écrire des informations de profilage convenant au programme d'analyse « gprof ». Vous devez utiliser cette option quand vous compilez les fichiers sources pour lesquels vous voulez obtenir des données, et vous devez également l'utiliser lors de l'édition des liens.

-Q

Faire afficher par le compilateur le nom de chaque fonction lors de sa compilation, et afficher certaines statistiques sur chaque passe quand il a terminé.

-ftime-report

Faire afficher par le compilateur certaines statistiques sur le temps consommé par chaque passe quand il a terminé.

-fmem-report

Faire afficher par le compilateur certaines statistiques sur l'allocation de mémoire permanente quand il a terminé.

-fprofile-arcs

Traiter les arcs durant la compilation pour générer des données de recouvrement ou pour un ordonnancement de blocs sur base du profil. Durant l'exécution, le programme enregistre le nombre de fois que chaque branchement est exécuté et le nombre de fois qu'il est emprunté. Quand le programme compilé se termine, il sauve ses données dans un fichier appelé nom-source.da pour chaque fichier source.

Pour l'ordonnancement de blocs sur base du profil, compilez le programme avec -fprofile-arcs plus les options d'optimisation et de génération de code, générez les informations de profil sur les arcs en exécutant le programme avec une charge de travail sélectionnée, et recompilez ensuite le programme avec les mêmes options d'optimisation et de génération de code plus -fbranch-probabilities.

L'autre utilisation de -fprofile-arcs est destinée à « gcov », quand il est utilisé avec l'option -ftest-coverage.

Avec -fprofile-arcs, pour chaque fonction de votre programme, GCC crée un graphe de flux du programme, et trouve ensuite un arbre de recouvrement minimum pour le graphe. Seuls les arcs non présents dans l'arbre doivent être traités : le compilateur ajoute du code pour compter le nombre de fois que ces arcs sont exécutés. Quand un arc est la seule sortie ou la seule entrée d'un bloc, le code d'instrumentation peut être ajouté au bloc ; sinon, un nouveau bloc de base doit être créé pour détenir le code d'instrumentation.

-ftest-coverage

Créer des fichiers de données pour l'utilitaire de couverture de code « gcov ». Le nom du fichier de données commence par le nom de votre fichier source :

-dlettres

Dire de créer des déchargements (images mémoire, dumps) de débogage durant la compilation aux moments spécifiés par lettres. Ceci est utilisé pour déboguer le compilateur. Les noms de fichiers pour la plupart des déchargements sont produits en concaténant un numéro de passe et un mot au nom du fichier source (p.ex. foo.c.00.rtl ou foo.c.01.sibling). Voici les lettres utilisables, et leur signification :

-fdump-unnumbered

Lors de déchargements de débogage (voyez l'option -d ci-dessus), ne pas sortir les numéros d'instructions et les numéros de lignes. Cela permet de faciliter l'utilisation de diff sur les déchargements de débogage lors des invocations du compilateur avec des options différentes, en particulier avec et sans -g.

-fdump-translation-unit (C et C++ uniquement)

-fdump-translation-unit-options (C et C++ uniquement)

Décharger une représentation de la structure d'arbre de l'unité de traduction entière dans un fichier. Le nom du fichier est créé en concaténant .tu au nom du fichier source. Si la forme -options est utilisée, options contrôle les détails du déchargement comme décrits par les options -fdump-tree.

-fdump-class-hierarchy (C++ uniquement)

-fdump-class-hierarchy-options (C++ uniquement)

Décharger une représentation de la hiérarchie de chaque classe et de la composition de la table des fonctions virtuelles dans un fichier. Le nom du fichier est créé en concaténant .class au nom du fichier source. Si la forme -options est utilisée, options contrôle les détails du déchargement comme décrits par les options -fdump-tree.

-fdump-tree-interrupteur (C++ uniquement)

-fdump-tree-interrupteur-options

(C++ uniquement)" 4 Contrôler le déchargement lors des différentes étapes du traitement de l'arbre de langage intermédiaire dans un fichier. Le nom du fichier est créé en concaténant un suffixe spécifique à l'interrupteur au nom du fichier source. Si la forme -options est utilisée, options est une liste d'options séparées par des - qui contrôlent les détails du déchargement. Toutes les options ne sont pas applicables à tous les déchargements ; celles qui ne sont pas significatives seront ignorées. Les options suivantes sont disponibles :

-fpretend-float

Quand on exécute un compilateur croisé (cross-compiler), prétendre que la machine cible utilise le même format de flottants que la machine hôte. Ceci provoque une sortie incorrecte des constantes flottantes réelles, mais la séquence réelle d'instructions sera probablement la même que celle que donnerait GCC s'il tournait sur la machine cible.

-save-temps

Stocker les fichiers intermédiaires « temporaires » habituels de façon permanente ; les placer dans le répertoire courant et les nommer sur base du fichier source. Donc, compiler foo.c avec -c -save-temps produirait les fichiers foo.i et foo.s, aussi bien que foo.o. Cela crée un fichier de sortie prétraité foo.i bien que le compilateur utilise maintenant normalement un préprocesseur intégré.

-time

Rapporter le temps CPU consommé par chaque sous-processus de la séquence de compilation. Pour les fichiers sources C, elle est constituée par le compilateur proprement dit et l'assembleur (plus l'éditeur de liens si une édition des liens est effectuée). La sortie ressemble à ceci :

        # cc1 0.12 0.01
        # as 0.00 0.01
    

Le premier nombre de chaque ligne est le « temps utilisateur », c.-à-d. le temps occupé à exécuter le programme en lui-même. Le second nombre est le « temps système », c.-à-d. le temps occupé à exécuter des routines du système d'exploitation pour le programme. Les deux nombres sont exprimés en secondes.

-print-file-name=bibliothèque

Afficher le nom de fichier absolu complet du fichier de bibliothèque qui serait utilisé lors de l'édition des liens et ne rien faire d'autre. Avec cette option, GCC ne compile ni ne lie quoi que ce soit ; il affiche simplement le nom du fichier.

-print-multi-directory

Afficher le nom de répertoire correspondant au groupe de bibliothèques sélectionné par d'autres interrupteurs présents sur la ligne de commandes. Ce répertoire est supposé être contenu dans GCC_EXEC_PREFIX.

-print-multi-lib

Afficher la correspondance entre les noms de répertoires comportant plusieurs bibliothèques, et les interrupteurs du compilateur qui les activent. Le nom du répertoire est séparé des interrupteurs par ;, et chaque interrupteur commence par un @} au lieu du @samp{-, sans espace entre les différents interrupteurs. C'est supposé faciliter le traitement par le shell.

-print-prog-name=programme

Comme -print-file-name, mais recherche un programme comme cpp.

-print-libgcc-file-name

Identique à -print-file-name=libgcc.a.

C'est utile quand vous utilisez -nostdlib ou -nodefaultlibs mais que vous voulez lier avec libgcc.a. Vous pouvez faire

      gcc -nostdlib <fichiers>... `gcc -print-libgcc-file-name`
    

-print-search-dirs

Afficher le nom du répertoire d'installation configuré et une liste de répertoires de programmes et de bibliothèques où gcc effectuera sa recherche -- et ne rien faire d'autre.

C'est utile quand gcc affiche le message d'erreur installation problem, cannot exec cpp0: No such file or directory (problème d'installation, ne peut effectuer un exec cpp0 : Aucun fichier ou répertoire de ce type). Pour résoudre ceci, vous pouvez placer cpp0 et les autres composants du compilateur là où gcc les pressent (NdT : du verbe pressentir), ou bien fixer la variable d'environnement GCC_EXEC_PREFIX au nom du répertoire où vous les avez installés. N'oubliez pas le « / » de queue.

-dumpmachine

Afficher la machine cible du compilateur (par exemple i686-pc-linux-gnu) -- et ne rien faire d'autre.

-dumpversion

Afficher la version du compilateur (par exemple, 3.0) -- et ne rien faire d'autre.

-dumpspecs

Afficher les specs intégrées du compilateur -- et ne rien faire d'autre. (C'est utilisé quand GCC lui-même est en cours de construction.)

Options contrôlant l'optimisation

Ces options contrôles différentes sortes d'optimisations :

-O

-O1

Optimiser. La compilation optimisante prend un peu plus de temps, et beaucoup plus de mémoire pour une grande fonction.

Sans -O, le but du compilateur est de réduire le coût dû à la compilation et de permettre au débogage de produire les résultats escomptés. Les instructions sont indépendantes : si vous stoppez le programme sur un point d'arrêt (breakpoint) entre des instructions, vous pouvez ensuite attribuer une nouvelle valeur à n'importe quelle variable ou modifier l'indicateur d'instruction courante (program counter) pour le faire pointer vers n'importe quelle autre instruction de la fonction et obtenir exactement les mêmes résultats que ceux que vous pourriez escompter en partant du code source.

Avec -O, le compilateur essaie de réduire la taille du code et le temps d'exécution, sans effectuer d'optimisation nécessitant beaucoup de temps de compilation.

-O2

Optimiser encore plus. GCC effectue pratiquement toutes les optimisations supportées qui n'impliquent pas un compromis espace/vitesse. Le compilateur n'effectue pas de déroulement des boucles ou de mise en ligne de fonctions quand vous spécifiez -O2. Comparée à -O, cette option augmente à la fois le temps de compilation et la performance du code généré.

-O2 active toutes les optimisations optionnelles à l'exception du déroulement des boucles, de la mise en ligne de fonctions, et du renommage de registres. Il active également l'option -fforce-mem sur toutes les machines, et élimine le pointeur de cadre sur les machines pour lesquelles faire de la sorte n'interfère pas avec le débogage.

Notez s.v.p. l'avertissement présenté sous -fgcse concernant l'invocation de -O2 pour des programmes utilisant des gotos calculés.

-O3

Optimiser toujours plus. -O3 active toutes les optimisations spécifiées par -O2 et active également les options -finline-functions et -frename-registers.

-O0

Ne pas optimiser.

-Os

Optimiser pour la taille. -Os active toutes les optimisations de -O2 qui n'augmentent typiquement pas la taille du code. Il effectue également des optimisations supplémentaires destinées à réduire la taille du code.

Si vous utilisez de multiples options -O, avec ou sans numéro de niveau, seule la dernière option de ce type sera prise en compte.

Les options de la forme -fdrapeau spécifient des drapeaux dépendants de la machine. La plupart des drapeaux ont à la fois les formes positive et négative ; la forme négative de -ffoo serait -fno-foo. Dans la table ci-dessous, seule une des formes est listée -- celle qui n'est activée par défaut. Vous pouvez imaginer l'autre forme en supprimant no- ou en l'ajoutant.

-ffloat-store

Ne pas stocker les variables flottantes dans des registres, et inhiber d'autres options qui pourrait interférer sur le fait qu'un flottant soit extrait d'un registre ou à partir de la mémoire.

Cette option empêche une précision excessive non désirable sur des machines telles que le 68000 où les registres flottants (du 68881) gardent plus de précision qu'un « double » est supposé avoir. Idem pour l'architecture x86. Pour la plupart des programmes, l'excès de précision ne fait que du bien, mais certains programmes se basent sur la définition précise du flottant IEEE. Utilisez -ffloat-store pour de tels programmes, après les avoir modifiés afin qu'ils stockent tous les calculs intermédiaires pertinents dans des variables.

-fno-default-inline

Ne pas rendre les fonctions membres en ligne par défaut simplement parce qu'elles sont définies à l'intérieur de la portée de la classe (C++ uniquement). Autrement, si vous spécifiez -O, les fonctions membres définies à l'intérieur de la portée de la classe sont compilées en ligne par défaut, c.-à-d. que vous n'êtes pas obligé d'ajouter inline devant le nom de la fonction membre.

-fno-defer-pop

Toujours dépiler les arguments de chaque appel de fonction dès que la fonction se termine. Pour les machines qui doivent dépiler les arguments après un appel de fonction, le compilateur laisse normalement les arguments s'accumuler sur la pile pour plusieurs appels de fonctions, et les dépile tous en une seule fois.

-fforce-mem

Force les opérandes mémoire à être copiés dans des registres avant de les employer dans des opérations arithmétiques. Ceci peut produire un meilleur code en faisant de toutes les références mémoire des sous-expressions potentiellement communes. Quand elles ne sont pas des sous-expressions communes, la combinaison d'instructions devrait éliminer le chargement séparé dans des registres. L'option -O2 active cette option.

-fforce-addr

Force les constantes d'adresse mémoire à être copiées dans des registres avant d'effectuer des opérations arithmétiques sur elles. Ceci peut produire du meilleur code exactement comme pourrait le faire -fforce-mem.

-fomit-frame-pointer

Ne pas conserver de pointeur de cadre dans un registre pour les fonctions qui n'en ont pas besoin. Ceci évite les instructions pour sauver, mettre à jour et restaurer les pointeurs de cadre ; cela permet aussi de libérer un registre supplémentaire qui pourra dès lors être disponible dans de nombreuses fonctions. Cela rend également le débogage impossible sur certaines machines.

Sur certaines machines, telles que le VAX, ce fanion n'a aucun effet, car la séquence standard d'appel traite automatiquement le pointeur de cadre, et rien n'est sauvé en prétendant qu'il n'existe pas. La macro de description de machine « FRAME_POINTER_REQUIRED » contrôle si une machine cible supporte de drapeau.

-foptimize-sibling-calls

Optimiser les appels de fonction soeur et récursifs terminaux.

-ftrapv

Cette option génère des interruptions pour le dépassement signé pour les opérations d'addition, de soustraction et de multiplication.

-fno-inline

Ne pas tenir compte du mot-clé « inline ». Normalement, cette option est utilisée pour empêcher le compilateur d'étendre des fonctions en ligne. Notez que si vous n'effectuez pas de compilation optimisante, aucune fonction ne sera développée en ligne.

-finline-functions

Intégrer toutes les fonctions simples dans leurs appelants. Le compilateur détermine heuristiquement quelles fonctions sont suffisamment simples pour valoir la peine d'être intégrées de cette façon.

Si tous les appels à une fonction donnée sont intégrés, et si la fonction est déclarée « static », alors la fonction ne fait normalement pas partie de la sortie de l'assembleur et ce de son pleindroit.

-finline-limit=n

Par défaut, gcc limite la taille des fonctions qui peuvent être mises en ligne. Ce drapeau permet de contrôle de cette limite pour les fonctions qui sont explicitement marquées comme étant en ligne (c.-à-d. marquées par le mot-clé inline ou définies dans la définition de classe en c++). n est la taille des fonctions qui peuvent être mises en ligne en nombre de pseudo-instructions (traitement des paramètres exclus). La valeur par défaut pour n est 600. Augmenter cette valeur peut résulter en un code plus « en ligne » au prix d'un temps de compilation et d'une consommation mémoire supérieurs. La baisser rend généralement la compilation plus rapide, et moins de code sera mis en ligne (ce qui signifie vraisemblablement des programmes plus lents). Cette option est particulièrement utile pour les programmes qui utilisent fortement la mise en ligne comme ceux basés sur les modèles récursifs en C++.

Note : le concept de pseudo-instruction représente, dans ce contexte particulier, une mesure abstraite de la taille d'une fonction. En aucune façon, il ne représente un nombre d'instructions d'assemblage et sa signification exacte pourrait de ce fait varier d'une version à une autre.

-fkeep-inline-functions

Même si les appels à une fonction donnée sont intégrés, et que la fonction est déclarée « static », produire néanmoins une version séparée de la fonction appelable à l'exécution. Cette option n'affecte pas les fonctions « extern inline ».

-fkeep-static-consts

Émettre des variables déclarées « static const » quand l'optimisation n'est pas activée, même si les variables ne sont pas référencées.

GCC active cette option par défaut. Si vous voulez forcer le compilateur à vérifier si la variable était référencée, que l'optimisation soit activée ou non, utilisez l'option -fno-keep-static-consts.

-fmerge-constants

Essayer de fusionner les constantes identiques (les constantes chaînes de caractères et les constantes flottantes) par delà les unités de compilation.

Cette option est utilisée par défaut pour la compilation optimisée si l'assembleur et l'éditeur de liens le supportent. Utilisez -fno-merge-constants pour interdire ce comportement.

-fmerge-all-constants

Essayer de fusionner les constantes identiques, et les variables identiques.

Cette option implique -fmerge-constants. En plus de -fmerge-constants, cela tient p.ex. même compte des tableaux initialisés avec des constantes ou des variables initialisées avec des constantes, de type intégral ou flottant. Des langages comme C ou C++ requièrent que chaque variable non automatique dispose d'un emplacement pour son usage exclusif, de sorte que l'utilisation de cette option résultera en un comportement non conforme.

-fno-function-cse

Ne pas placer d'adresse de fonction dans des registres ; faire contenir explicitement dans chaque instruction qui appelle une fonction constante l'adresse de cette fonction.

Cette option résulte en un code moins efficace, mais certaines bidouilles étranges qui altèrent la sortie de l'assembleur peuvent être embrouillées si cette option n'est pas utilisée.

-ffast-math

Spécifie -fno-math-errno, -funsafe-math-optimizations, et -fno-trapping-math.

Cette option provoque la définition de la macro du préprocesseur « __FAST_MATH__ ».

Cette option ne devrait jamais être activée par une option -O car elle peut résulter en une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications ISO ou IEEE pour les fonctions mathématiques.

-fno-math-errno

Ne pas définir ERRNO après l'appel de fonctions mathématiques qui sont exécutées en une seule instruction, comme p.ex. sqrt. Un programme qui se base sur les exceptions IEEE pour le traitement des erreurs mathématiques pourrait utiliser ce drapeau pour la vitesse tout en maintenant la compatibilité arithmétique IEEE.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le défaut est -fmath-errno.

-funsafe-math-optimizations

Permettre les optimisations pour l'arithmétique flottante qui (a) supposent que les arguments et les résultats sont valides et (b) peuvent violer les standards IEEE ou ANSI. Quand elles sont utilisées au moment de l'édition des liens, elles peuvent inclure des bibliothèques ou des fichiers de démarrage qui modifient le mot de contrôle par défaut de la FPU ou d'autres optimisations similaires.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le comportement par défaut est celui de -fno-unsafe-math-optimizations.

-fno-trapping-math

Compiler du code supposant que les opérations flottantes ne peuvent pas générer d'interruptions visibles par l'utilisateur. Définir cette option peut également accélérer si l'on se base sur l'arithmétique IEEE « non-stop », par exemple.

Cette option ne devrait jamais être activée par une option -O car il peut en résulter une sortie incorrecte pour les programmes qui dépendent d'une implémentation exacte des règles/spécifications de l'IEEE ou de l'ISO concernant les fonctions mathématiques.

Le comportement par défaut est celui de -ftrapping-math.

Les options suivantes contrôlent des optimisations spécifiques. L'option -O2 active toutes ces optimisations sauf -funroll-loops et -funroll-all-loops. Sur la plupart des machines, l'option -O active les options -fthread-jumps et -fdelayed-branch, mais des machines spécifiques peuvent les traiter différemment.

Vous pouvez utiliser les drapeaux suivants dans les rares cas où vous désirez régler avec précision les optimisations à effectuer.

Toutes les optimisations effectuées par GCC n'ont pas forcément d'options -f permettant leur contrôle.

-fstrength-reduce

Effectuer les optimisations de réduction de force des boucles et d'élimination des variables d'itération.

-fthread-jumps

Effectuer des optimisations où l'on vérifie si un saut se branche vers un emplacement où une autre comparaison englobée par la première est trouvée. Si c'est le cas, le premier branchement est redirigé soit vers la destination du second branchement, soit sur le point le suivant immédiatement, en fonction de la valeur de vérité de la condition.

-fcse-follow-jumps

Dans l'élimination de sous-expressions communes, parcourir les instructions de saut quand la cible du saut n'est atteinte pas aucun autre chemin. Par exemple, quand CSE rencontre une instruction « if » possédant une clause « else », CSE suivra le saut quand la condition testée est fausse.

-fcse-skip-blocks

C'est similaire à -fcse-follow-jumps, mais fait suivre par le CSE les sauts conditionnels au-dessus de blocs. Quand CSE rencontre une simple instruction « if » sans clause else, -fcse-skip-blocks fait suivre par CSE les sauts autour du corps du « if ».

-frerun-cse-after-loop

Relancer l'élimination des sous-expressions communes après avoir effectué les optimisations de boucles.

-frerun-loop-opt

Lancer deux fois l'optimiseur de boucles.

-fgcse

Effectuer une passe globale d'élimination des sous-expressions communes. Cette passe effectue également une propagation globale de constantes et de copies.

Note : Lors de la compilation d'un programme utilisant des gotos calculés, une extension GCC, vous pouvez obtenir une meilleure performance à l'exécution si vous désactivez la passe d'élimination des sous-expressions communes globales en ajoutant -fno-gcse sur la ligne de commandes.

-fgcse-lm

Quand -fgcse-lm est activé, l'élimination des sous-expressions communes globales essaiera de déplacer les chargements (instructions load) qui ne sont invalidés que par des instructions de mémorisation (instructions store).

-fgcse-sm

Quand -fgcse-sm est activé, une passe de déplacement des « store » est exécutée après l'élimination des sous-expressions communes globales. Cette passe essaiera de déplacer les « store » en dehors des boucles. Quand cette option est utilisée en conjonction avec -fgcse-lm, les boucles contenant une séquence load/store peuvent être remplacées par un « load » avant la boucle et un « store » après la boucle.

-fdelete-null-pointer-checks

Utiliser une analyse des flux de données globale pour identifier et éliminer les contrôles inutiles de pointeurs null. Le compilateur suppose que le déréférencement d'un pointeur null aurait arrêté le programme. Si un pointeur est contrôlé après avoir déjà été déréférencé, il ne peut être null.

Dans certains environnements, cette supposition n'est pas vraie, et les programmes peuvent sans risque déréférencer des pointeurs null. Utilisez -fno-delete-null-pointer-checks pour désactiver cette optimisation pour les programmes qui dépendent de ce comportement.

-fexpensive-optimizations

Effectuer un certain nombre d'optimisations mineures qui sont relativement coûteuses.

-foptimize-register-move

-fregmove

Essayer de réattribuer des numéros de registres dans les instructions move et comme opérandes d'autres instructions simples pour maximiser le nombre d'attachements à des registres. C'est spécialement utile sur les machines utilisant des instructions à deux opérandes. GCC active cette optimisation par défaut avec -O2 ou supérieur.

Notez que -fregmove et -foptimize-register-move constituent la même optimisation.

-fdelayed-branch

Si supporté par la machine cible, essayer de réordonner les instructions pour exploiter des slots d'instructions disponibles après des instructions de branchement différés.

-fschedule-insns

Si supporté par la machine cible, tente de réordonner les instructions pour éliminer les pertes de vitesse à l'exécution dues à des données requises indisponibles. Cela aide les machines ayant des flottants ou des instructions de chargement en mémoire lents, en autorisant d'autres instructions à être exécutées avant que le résultat du chargement ou de l'instruction flottante ne soit requis.

-fschedule-insns2

Similaire à -fschedule-insns, mais requiert une passe supplémentaire d'ordonnancement des instructions après que l'allocation des registres ait été effectuée. C'est spécialement utile sur des machines avec un nombre de registres relativement petit et où les instructions de chargement en mémoire prennent plus d'un cycle.

-ffunction-sections

-fdata-sections

Placer chaque fonction ou élément de données dans sa propre section dans le fichier de sortie si la cible supporte des sections arbitraires. Le nom de la fonction ou le nom de l'élément de données détermine le nom de la section dans le fichier de sortie.

Utilisez ces options sur des systèmes où l'éditeur de liens peut effectuer des optimisations pour améliorer la localisation des références dans l'espace d'instructions. Les processeurs HPPA exécutant HP-UX et les processeurs Sparc exécutant Solaris 2 disposent d'éditeurs de liens prenant en charge de telles optimisations. D'autres systèmes utilisant le format objet ELF en plus de AIX pourraient disposer de ces optimisations dans le futur.

N'utilisez ces options que lorsqu'il y a des bénéfices importants à faire de la sorte. Quand vous spécifiez ces options, l'assembleur et l'éditeur de liens créeront des fichiers objets et exécutables plus gros, et qui seront également plus lents. Vous ne pourrez pas utiliser « gprof » sur tous les systèmes si vous spécifiez cette option, et vous pourriez avoir des problèmes lors du débogage si vous utilisez cette option conjointement avec -g.

-fcaller-saves

Permet à des valeurs d'être allouées dans des registres qui seront écrasés lors d'appels de fonction, en émettant des instructions supplémentaires pour sauver et restaurer les registres autour de tels appels. Une telle allocation est effectuée uniquement quand elle semble produire du meilleur code que celui qui serait produit autrement.

Cette option est toujours activée par défaut sur certaines machines, en l'occurrence celles qui n'ont d'habitude pas de registres préservés lors de l'appel à utiliser à la place.

Sur toutes les machines, les niveaux d'optimisation 2 et supérieurs activent ce drapeau par défaut.

-funroll-loops

Dérouler les boucles dont le nombre d'itérations peut être déterminé au moment de la compilation ou en entrant dans la boucle. -funroll-loops implique à la fois -fstrength-reduce et -frerun-cse-after-loop. Cette option crée un code de plus grande taille, et peut (ou pas) le rendre plus rapide.

-funroll-all-loops

Dérouler toutes les boucles, même si leur nombre d'itérations est indéterminé au moment de l'entrée dans la boucle. Cela ralentit habituellement les programmes. -funroll-all-loops implique les mêmes options que -funroll-loops.

-fprefetch-loop-arrays

Si c'est supporté par la machine cible, générer des instructions de préchargement mémoire afin d'améliorer la performance des boucles qui accèdent à des grands tableaux.

-fmove-all-movables

Forcer tous les calculs invariants dans les boucles à être déplacés en dehors de la boucle.

-freduce-all-givs

Forcer toutes les variables d'induction générale dans les boucles à subir la réduction de force des boucles.

Note : Quand vous compilez des programmes écrits en Fortran, -fmove-all-movables et -freduce-all-givs sont activés par défaut quand vous utilisez l'optimiseur.

Ces options peuvent générer un code meilleur ou moins bon. Les résultats sont fortement dépendants de la structure des boucles à l'intérieur du code source.

Ces deux options vont être supprimées un jour ou l'autre, une fois qu'elles auront aidé à déterminer l'efficacité de différentes approches d'amélioration des optimisations de boucles.

Faites nous s'il vous plaît savoir (<gcc@gcc.gnu.org> et <fortran@gnu.org>) comment l'utilisation de ces options affecte la performance de votre code de production. Nous sommes très intéressés en du code qui tourne plus lentement quand ces options sont activées.

-fno-peephole

-fno-peephole2

Désactiver toute optimisation peephole spécifique à la machine. La différence entre -fno-peephole et -fno-peephole2 se situe dans la façon dont elles sont implémentées dans le compilateur ; certaines cibles utilisent l'une, des autres l'autre, et quelques unes les deux.

-fbranch-probabilities

Après avoir exécuté un programme compilé avec -fprofile-arcs, vous pouvez le compiler une deuxième fois en utilisant -fbranch-probabilities, pour améliorer les optimisations basées sur le nombre de fois que chaque branchement a été emprunté. Quand le programme compilé avec -fprofile-arcs se termine, il sauve les nombres d'exécutions d'arcs dans un fichier appelé nom-source.da pour chaque fichier source. Les informations contenues dans ce fichier de données sont très dépendantes de la structure du code généré, et vous devez donc utiliser le même code source et les mêmes options d'optimisation lors des deux compilations.

Avec -fbranch-probabilities, GCC appose une note REG_EXEC_COUNT sur la première instruction de chaque bloc de base, et une note REG_BR_PROB sur chaque JUMP_INSN et CALL_INSN. Celles-ci peuvent être utilisées pour améliorer l'optimisation. Actuellement, elles ne sont utilisées qu'à un seul endroit : dans reorg.c, au lieu de deviner quel chemin un branchement est le plus susceptible d'emprunter, les valeurs REG_BR_PROB sont utilisées pour déterminer avec exactitude quel chemin est emprunté le plus souvent.

-fno-guess-branch-probability

Ne pas deviner les probabilités de branchement en utilisant un modèle
aléatoire.

Parfois, gcc choisira un modèle aléatoire pour deviner les probabilités de branchement, quand aucun autre n'est disponible que ce soit depuis la rétroaction de profilage (-fprofile-arcs) ou depuis __builtin_expect. Cela signifie que différents lancements du compilateur sur le même programme peuvent produire du code objet différent.

Dans un système temps-réel « réel », différents lancements du compilateur ne peuvent pas produire du code au comportement différent ; la minimisation du non déterminisme est primordiale. Cet interrupteur permet aux utilisateurs de réduire le non déterminisme, éventuellement au prix d'une optimisation inférieure.

-fstrict-aliasing

Permet au compilateur de supposer les règles d'aliasing les plus strictes applicables au langage en cours de compilation. Pour C (et C++), ceci active les optimisations basées sur le type des expressions. En particulier, un objet d'un type est supposé ne jamais résider à la même adresse qu'un objet d'un type différent, à moins que les types ne soient pratiquement identiques. Par exemple, un « unsigned int » peut devenir un alias d'un « int », mais pas d'un « void* » ou d'un « double ». Un type caractère peut devenir un alias de n'importe quel autre type.

Faites spécialement attention à du code comme celui-ci :

        union a_union {
          int i;
          double d;
        };
    

        int f() {
          a_union t;
          t.d = 3.0;
          return t.i;
        }
    

La pratique consistant à lire à partir d'un membre d'une union différent de celui le plus récemment écrit (appelée « type-punning ») est courante. Même avec -fstrict-aliasing, le type-punning est autorisé, à condition que la mémoire soit accédée via le type union. De la sorte, le code ci-dessus fonctionnera comme prévu. Ce ne sera pas forcément le cas pour ce code-ci :

        int f() {
          a_union t;
          int* ip;
          t.d = 3.0;
          ip = &t.i;
          return *ip;
        }
    

Chaque langage souhaitant effectuer une analyse d'alias spécifique au langage devrait définir une fonction qui calcule, pour un noeud d'« arbre » donné, un jeu d'alias pour ce noeud. Les noeuds faisant partie de différents jeux d'alias ne sont pas autorisés comme alias. Comme exemple, voyez la fonction frontale C « c_get_alias_set ».

-falign-functions

-falign-functions=n

Aligner le début des fonctions à la première puissance de deux supérieure à n, en passant jusqu'à n octets. Par exemple, -falign-functions=32 aligne les fonctions à la prochaine limite de 32 octets, mais -falign-functions=24 alignerait à la prochaine limite de 32 octets uniquement si cela peut être fait en passant jusqu'à 23 octets.

-fno-align-functions et -falign-functions=1 sont équivalents et signifient que les fonctions ne seront pas alignées.

Certains assembleurs ne supportent ce drapeau que lorsque n est une puissance de deux ; dans ce cas, il est arrondi au chiffre supérieur.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-falign-labels

-falign-labels=n

Aligner toutes les cibles de branchement à des limites de puissances de deux, passant jusqu'à n octets comme -falign-functions. Cette option peut facilement ralentir le code, car il doit insérer des opérations factices jusqu'à ce que la cible du branchement soit atteinte dans le flux habituel du code.

Si -falign-loops ou -falign-jumps sont applicables et plus grands que cette valeur, alors leurs valeurs sont utilisées à laplace.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine qui est très certainement 1, ce qui signifie aucun alignement.

-falign-loops

-falign-loops=n

Aligner les boucles à des limites de puissances de deux, passant jusqu'à n octets comme -falign-functions. On espère que la boucle sera exécutée plusieurs fois, ce qui se fera pour toute exécution des opérations factices.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-falign-jumps

-falign-jumps=n

Aligner les cibles de branchement à des limites de puissances de deux, pour les cibles de branchement où les cibles ne peuvent être atteintes que par un saut, en passant jusqu'à n octets comme -falign-functions. Dans ce cas, aucune opération factice ne doit être exécutée.

Si n n'est pas spécifié, utiliser une valeur par défaut dépendante de la machine.

-fssa

Effectuer des optimisations dans la forme Static Single Assignment (affectation statique simple). Le graphe de flux de chaque fonction est traduit sous la forme SSA, les optimisations sont effectuées, et le graphe de flux est retraduit à partir de la forme SSA. Les utilisateurs ne devraient pas spécifier cette option, car elle n'est pas encore prête pour une utilisation en production.

-fssa-ccp

Effectuer une Sparse Conditional Constant Propagation (Ndt : propagation conditionnelle clairsemée de constantes ?) dans la forme SSA. Requiert -fssa. Comme -fssa, c'est une fonctionnalité expérimentale.

-fssa-dce

Effectuer une élimination agressive du code mort de la forme SSA. Requiert -fssa. Comme -fssa, c'est une fonctionnalité expérimentale.

-fsingle-precision-constant

Traiter les constantes flottantes en tant que constantes en simple précision au lieu de les convertir implicitement en constantes en double précision.

-frename-registers

Essayer d'éviter des fausses dépendances dans le code ordonnancé en utilisant des registres libres après l'allocation des registres. Cette optimisation bénéficiera le plus aux processeurs possédant beaucoup de registres. Elle peut néanmoins rendre le débogage impossible, puisque les variables ne résideront plus dans un « registre maison ».

-fno-cprop-registers

Après l'allocation des registres et le découpage des instructions subséquent, nous effectuons une passe de copie-propagation pour essayer de réduire les dépendances d'ordonnancement et éliminer occasionnellement la copie.

--param nom=valeur

À certains endroits, GCC utilise différentes constantes pour contrôler la quantité d'optimisation qui est effectuée. Par exemple, GCC ne mettra pas en ligne des fonctions contenant plus qu'un certain nombre d'instructions. Vous pouvez contrôler certaines de ces constantes sur la ligne de commandes en utilisant l'option --param.

Dans chaque cas, la valeur est un entier. Les choix permis pour nom sont donnés dans la table suivante :

Options contrôlant le préprocesseur

Ces options contrôlent le préprocesseur C, qui est exécuté sur chaque fichier source C avant la compilation réelle.

Si vous utilisez l'option -E, rien n'est fait à part le prétraitement. Certaines de ces options n'ont de sens que combinées avec -E car elles rendent la sortie du préprocesseur inadaptée à une compilation réelle.

Vous pouvez utiliser -Wp,option pour passer outre le pilote du compilateur et passer l'option directement au préprocesseur. Si l'option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules. Néanmoins, beaucoup d'options sont modifiées, traduites ou interprétées par le pilote du compilateur avant d'être passées au préprocesseur, et -Wp contourne résolument cette phase. L'interface directe du préprocesseur n'est pas documentée et est sujette à des changements, et vous devriez par conséquent éviter d'utiliser -Wp à chaque fois que c'est possible et laisser le pilote traiter lui-même les options.

-D nom

Prédéfinir la macro nom, possédant la définition « 1 ».

-D nom=définition

Prédéfinir la macro nom, possédant la définition définition. Il n'y a aucune restriction quant au contenu de la définition, mais si vous invoquez le préprocesseur depuis un shell ou un programme de type shell, vous pourriez être dans l'obligation d'utiliser la syntaxe de protection du shell pour protéger les caractères comme les espaces qui y ont une signification spéciale.

Si vous voulez définir une macro du type fonction sur la ligne de commandes, écrivez sa liste d'arguments avec les parenthèses entourantes avant le signe égal (s'il y en a un). Les parenthèses sont significatives dans la plupart des shells, et vous devrez donc protéger l'option. -D'nom(args...)=définition' fonctionne avec sh et csh.

Les options -D et -U sont traitées dans leur ordre d'apparition sur la ligne de commandes. Toutes les options -imacros fichier et -include fichier sont traitées après toutes les options -D et -U.

-U nom

Annuler toute définition précédente de nom, qu'elle soit intégrée ou fournie à l'aide d'une option -D.

-undef

Ne pas prédéfinir de macro spécifique au système. Les macros prédéfinies habituelles restent définies.

-I rép

Ajouter le répertoire rép à la liste des répertoires où chercher les fichiers d'en-tête. Les répertoires nommés avec -I sont parcourus avant les répertoires d'inclusion système standard.

Il est dangereux de spécifier un répertoire d'inclusion système standard dans une option -I. Cela fait échouer le traitement spécial des en-têtes système. Cela peut également faire échouer les réparations des en-têtes système bogués qu'effectue GCC lors de son installation.

-o fichier

Écrire la sortie dans le fichier. C'est la même chose que de spécifier fichier comme second argument non-option pour cpp. gcc a une interprétation différente du second argument non-option ; vous devez donc utiliser -o pour spécifier le fichier de sortie.

-Wall

Active tous les avertissements optionnels qui sont désirables pour du code normal. Actuellement, il s'agit de -Wcomment et -Wtrigraphs. Notez que beaucoup des avertissements du préprocesseur sont activés par défaut et n'ont pas d'option permettant de les contrôler.

-Wcomment

-Wcomments

Avertir quand une séquence de début de commentaire /* apparaît dans un commentaire /*, ou chaque fois qu'un backslash suivi d'un saut de ligne apparaît dans un commentaire //. (Les deux formes ont le même effet.)

-Wtrigraphs

Avertir quand des trigraphes sont rencontrés. Cette option n'avait auparavant d'effet que si -trigraphs était également spécifié, mais fonctionne maintenant indépendamment. Des avertissements ne sont pas fournis pour les trigraphes présents à l'intérieur de commentaires, car ils n'affectent pas la signification du programme.

-Wtraditional

Avertir de certaines constructions qui se comportent différemment en C traditionnel et en C ISO. Avertir également des constructions C ISO qui n'ont pas d'équivalent en C traditionnel, et des constructions problématiques qui devraient être évitées.

-Wimport

Avertir la première fois qu'un #import est utilisé.

-Wundef

Avertir quand un identificateur qui n'est pas une macro est rencontré dans une directive #if, en dehors de defined. De tels identificateurs sont remplacés par zéro.

-Werror

Traiter les avertissements comme des erreurs pures et dures. Le code source qui déclenche des avertissements sera rejeté.

-Wsystem-headers

Afficher des messages d'avertissement pour du code des en-têtes système. Ils sont normalement inutiles pour trouver des bogues dans votre propre code, et par conséquent supprimés. Si vous êtes responsable de la bibliothèque système, vous pourriez vouloir les visualiser.

-w

Supprimer tous les avertissements, même ceux que GNU CPP émet par défaut.

-pedantic

Émettre tous les diagnostics obligatoires listés dans le standard C. Certains d'entre eux sont laissés de côté par défaut, car ils se déclenchent fréquemment dans du code inoffensif.

-pedantic-errors

Émettre tous les diagnostics obligatoires, et les traiter comme des erreurs. Cela inclut les diagnostics obligatoires que GCC émet sans -pedantic, mais traite comme des avertissements.

-M

Au lieu de sortir les résultats du prétraitement, générer une règle convenant à make qui décrit les dépendances du fichier source principal. Le préprocesseur génère une règle make contenant le nom du fichier objet pour ce fichier source, un signe deux-points, et le nom de tous les fichiers inclus, y compris ceux provenant des options de ligne de commandes -include ou -imacros.

À moins que cela ne soit spécifié explicitement (avec -MT ou -MQ), le nom du fichier objet est constitué du nom de base du fichier source où le suffixe éventuel est remplacé par le suffixe de fichier objet. S'il y a beaucoup de fichiers inclus, alors la règle est découpée en plusieurs lignes en utilisant \-newline. La règle n'a pas de commande.

Cette option ne supprime pas la sortie de débogage du préprocesseur, comme -dM. Pour éviter de mélanger une telle sortie de débogage avec les règles de dépendances, vous devriez spécifier explicitement le fichier de sortie des dépendances avec -MF, ou utiliser une variable d'environnement comme DEPENDENCIES_OUTPUT. La sortie de débogage sera toujours envoyée dans le flux de sortie normal comme de coutume.

Passer -M au pilote implique -E.

-MM

Comme -M, mais ne pas mentionner les fichiers d'en-tête qui sont trouvés dans les répertoires d'en-tête système, ni les fichiers d'en-tête qui sont inclus, directement ou indirectement, depuis un tel en-tête.

Cela implique que le choix de crochets pointus (< et >) ou de guillemets dans une directive #include ne détermine pas en lui-même si l'en-tête apparaîtra dans la sortie de dépendances de -MM. C'est un léger changement dans la sémantique depuis les versions 3.0 et antérieures de GCC.

-MF fichier

@anchor{-MF} Quand utilisé avec -M ou -MM, spécifie un fichier où écrire les dépendances. Si aucun interrupteur -MF n'est fourni, le préprocesseur envoie les règles au même endroit où il aurait envoyé la sortie prétraitée.

Quand il est utilisé avec les options du pilote -MD ou -MMD, -MF surcharge le fichier de sortie des dépendances par défaut.

-MG

Quand utilisé avec -M ou -MM, -MG indique de traiter les fichiers d'en-tête manquants comme des fichiers générés, et supposer qu'ils résident dans le même répertoire que le fichier source. Cela supprime la sortie prétraitée, puisqu'un fichier d'en-tête manquant constitue normalement une erreur.

Cette fonctionnalité est utilisée dans la mise à jour automatique de makefiles.

-MP

Cette option indique à CPP d'ajouter une cible « phony » pour chaque dépendance autre que le fichier principal, ne les faisant dépendre de ce fait de rien du tout. Ces règles factices surmontent des erreurs que vous donne make si vous supprimez des fichiers d'en-tête sans mettre à jour le Makefile pour qu'il concorde.

Voici une sortie typique :

        test.o: test.c test.h
    

        test.h:
    

-MT cible

Changer la cible de la règle émise lors de la génération des dépendances. Par défaut, CPP prend le nom du fichier d'entrée principal, chemin inclus, supprime tout suffixe de fichier comme .c, et concatène le suffixe de fichier objet habituel de la plate-forme. Le résultat constitue la cible.

Une option -MT définira la cible pour qu'elle soit exactement la chaîne de caractères que vous spécifiez. Si vous voulez plusieurs cibles, vous pouvez les spécifier comme un unique argument de -MT, ou utiliser plusieurs options -MT.

Par exemple, -MT '$(objpfx)foo.o' pourrait donner

        $(objpfx)foo.o: foo.c
    

-MQ cible

Comme -MT, mais protège les caractères qui sont spéciaux pour Make. -MQ '$(objpfx)foo.o' donne

        $$(objpfx)foo.o: foo.c
    

La cible par défaut est automatiquement protégée, comme si elle avait été fournie avec -MQ.

-MD

-MD est équivalent à -M -MF fichier, sauf que -E n'est pas impliqué. Le pilote détermine le fichier en fonction de l'utilisation éventuelle d'une option -o est donnée. Si c'est le cas, le pilote utilise son argument mais avec un suffixe .d ; sinon, il prend le nom de base du fichier d'entrée et lui applique un suffixe .d.

Si -MD est utilisé en conjonction avec -E, tout interrupteur -o est censé spécifier le fichier de sortie des dépendances (sauf @pxref{-MF}), mais s'il est utilisé sans -E, chaque -o est censé spécifier un fichier objet cible.

Puisque -E n'est pas impliqué, -MD peut être utilisé pour générer un fichier de sortie de dépendances comme effet de bord du processus de compilation.

-MMD

Comme -MD, sauf que seuls les fichiers d'en-tête utilisateurs sont mentionnés, et pas les fichiers d'en-tête système.

-x c

-x c++

-x objective-c

-x assembler-with-cpp

Spécifier le langage source : C, C++, Objective-C, ou assembleur. Cela n'a rien à voir avec la conformité aux standards ou avec des extensions ; cela sélectionne simplement à quelle syntaxe de base on doit s'attendre. Si vous ne fournissez aucune de ces options, cpp déduira le langage à partir de l'extension du fichier source : .c, .cc, .m ou .S. Certaines autres extensions habituelles pour le C++ et l'assembleur sont également reconnues. Si cpp ne reconnaît pas l'extension, il traitera le fichier comme étant du C ; c'est le mode le plus générique.

Note : De précédentes versions de cpp acceptaient une option -lang qui sélectionnait à la fois le langage et le niveau de conformité aux standards. Cette option a été supprimée, car elle entre en conflit avec l'option -l.

-std=standard

-ansi

Spécifier le standard auquel le code devrait se conformer. Actuellement, cpp ne connaît que les standards du C ; d'autres standards de languages seront ajoutés dans le futur.

Le standard peut être :

-I-

Diviser le chemin d'inclusion. Tout répertoire spécifié avec une option -I avant -I- n'est parcouru que pour les en-têtes requis avec « #include "fichier" » ; il n'est pas parcouru pour des « #include <fichier> ». Si des répertoires additionnels sont spécifiés par des options -I après le -I-, ces répertoires sont parcourus pour chaque directive #include.

De plus, -I- empêche l'utilisation du répertoire courant (où est situé le fichier d'entrée actuel) comme premier répertoire de recherche pour « #include "fichier" ».

-nostdinc

Ne pas chercher les fichiers d'en-tête dans les répertoires standard du système. Seuls les répertoires que vous avez spécifiés avec des options -I (et le répertoire courant, si c'est approprié) sont parcourus.

-nostdinc++

Ne pas rechercher de fichiers d'en-tête dans les répertoires standard spécifiques à C++, mais toujours effectuer une recherche dans les autres répertoires standard. (Cette option est utilisée pour compiler la bibliothèque C++.)

-include fichier

Traiter fichier comme si « #include "fichier" » était apparu comme première ligne du fichier source principal. Néanmoins, le premier répertoire parcouru pour trouver fichier est le répertoire de travail du préprocesseur plutôt que le répertoire contenant le fichier source principal. S'il n'est pas trouvé là, il est recherché dans le reste de la chaîne de recherche « #include "..." » comme de coutume.

Si plusieurs options -include sont fournies, les fichiers sont inclus dans leur ordre d'apparition sur la ligne de commandes.

-imacros fichier

Exactement comme -include, sauf que toute sortie produite lors de l'analyse du fichier est jetée. Les macros qu'il définit restent définies. Cela vous permet d'obtenir toutes les macros d'un en-tête sans devoir également traiter ses déclarations.

Tous les fichiers spécifiés par -imacros sont traités avant tous les fichiers spécifiés par -include.

-idirafter répertoire

Rechercher des fichiers d'en-tête dans le répertoire, mais après que les répertoires spécifiés par -I et les répertoires système standard aient été épuisés. répertoire est traité comme un répertoire d'inclusion système.

-iprefix préfixe

Spécifier le préfixe des options -iwithprefix ultérieures. Si le préfixe représente un répertoire, vous devriez inclure le / final.

-iwithprefix répertoire

-iwithprefixbefore répertoire

Concaténer répertoire au préfixe spécifié précédemment avec -iprefix, et ajouter le répertoire résultant au chemin de recherche d'inclusion. -iwithprefixbefore le place au même endroit que le ferait -I ; -iwithprefix le place au même endroit que -idirafter.

L'utilisation de ces options est découragée.

-isystem répertoire

Rechercher des fichiers d'en-tête dans le répertoire, après tous les répertoires spécifiés par -I, mais avant les répertoires système standard. Le marquer comme étant un répertoire système, afin qu'il ait droit au même traitement spécial que celui qui s'applique aux répertoires système standard.

-fpreprocessed

Indiquer au préprocesseur que le fichier d'entrée a déjà été prétraité. Cela supprime certaines choses comme l'expansion des macros, la conversion des trigraphes, le découpage de sauts de ligne protégés (escaped newline splicing), et le traitement de la plupart des directives. Le préprocesseur reconnaît et supprime toujours les commentaires, afin que vous puissiez passer au compilateur un fichier prétraité avec -C sans conséquence fâcheuse. Dans ce mode, le préprocesseur intégré est un peu plus qu'un analyseur lexical pour les frontaux.

-fpreprocessed est implicite si le fichier d'entrée possède l'une des extensions .i, .ii ou .mi. Ce sont les extensions que GCC utilise pour les fichiers prétraités créés par -save-temps.

-ftabstop=largeur

Fixer la distance entre les taquets de tabulation. Cela aide le préprocesseur à rapporter des numéros de colonnes corrects dans les avertissements ou erreurs, même si des tabulations apparaissent sur la ligne. Si la valeur est plus petite que 1 ou plus grande que 100, l'option est ignorée. La distance par défaut est 8.

-fno-show-column

Ne pas afficher les numéros des colonnes dans les diagnostics. Cela peut être nécessaire si les diagnostics sont exploités par un programme qui ne comprend pas les numéros de colonnes, comme dejagnu.

-A prédicat=réponse

Faire une assertion de prédicat prédicat et de réponse réponse. Cette forme est préférée à la forme plus ancienne -A prédicat(réponse), qui est toujours supportée, car n'utilisant pas les caractères spéciaux du shell.

-A -prédicat=réponse

Annuler une assertion de prédicat prédicat et de réponse réponse.

-A-

Annuler toutes les assertions prédéfinies et toutes les assertions précédant cette option sur la ligne de commandes. Supprimer également la définition de toutes les macros prédéfinies et de toutes les macros préalablement spécifiées sur la ligne de commandes. (C'est une excroissance historique et cela pourrait changer dans le futur.)

-dCARS

CARS est une séquence constituée d'un ou de plusieurs des caractères suivants, non précédés d'une espace. D'autres caractères sont interprétés par le compilateur lui-même, ou réservés pour des versions futures de GCC, et sont par conséquent ignorés silencieusement. Si vous spécifiez des caractères dont les comportements ne sont pas compatibles, le résultat est indéfini.

-P

Empêcher la génération de marqueurs de ligne dans la sortie du préprocesseur. Cela pourrait être utile quand on exécute le préprocesseur sur quelque chose qui n'est pas du code C, et qui sera envoyé à un programme qui pourrait être embrouillé à cause des marqueurs de ligne.

-C

Ne pas éliminer les commentaires. Tous les commentaires sont passés dans le fichier de sortie, sauf ceux présents dans les directives traitées, qui sont effacés en même temps que la directive.

Vous devriez vous attendre à des effets de bord quand vous utilisez -C ; cette option force le préprocesseur à traiter les commentaires comme des éléments lexicaux à part entière. Par exemple, les commentaires apparaissant au début de ce qui serait une ligne de directive ont pour effet de transformer cette ligne en une ligne de code source ordinaire, puisque le premier élément lexical de la ligne n'est plus un #.

-gcc

Définir les macros __GNUC__, __GNUC_MINOR__ et __GNUC_PATCHLEVEL__. Elles sont définies automatiquement quand vous utilisez gcc -E ; vous pouvez les désactiver dans ce cas avec -no-gcc.

-traditional

Essayer d'imiter le comportement du C à l'ancienne, en opposition avec le C ISO.

-trigraphs

Prendre en charge les séquences de trigraphes. Ce sont des séquences de trois caractères, débutant toutes par ??, qui sont définies par le C ISO pour représenter des caractères uniques. Par exemple, ??/ signifie \, de sorte que '??/n' est une constante caractère qui représente un saut de ligne. Par défaut, GCC ignore les trigraphes, mais dans les modes de conformité aux standards, il les convertit. Voyez les options -std et -ansi.

Les neufs trigraphes et leur valeur de remplacement sont :

     Trigraphe    :  ??(  ??)  ??<  ??>  ??=  ??/  ??'  ??!  ??-
     Remplacement :    [    ]    {    }    #    \    ^    ⎪    ~
    

-remap

Activer du code spécial pour s'accomoder de systèmes de fichiers qui ne permettent que des noms de fichiers très courts, comme MS-DOS.

-$

Interdire l'utilisation du $ dans les identificateurs. Le standard C autorise les implémentations à définir des caractères supplémentaires pouvant apparaître dans les identificateurs. Par défaut, GNU CPP autorise le $, une extension habituelle.

-h

--help

--target-help

Afficher du texte décrivant toutes les options de ligne de commandes au lieu de prétraiter quoi que ce soit.

-v

Mode verbeux. Afficher le numéro de version de GNU CPP au début de l'exécution, et rapporter la forme finale du chemin d'inclusion.

-H

Afficher le nom de chaque fichier d'en-tête utilisé, en plus d'autres activités normales. Chaque nom est indenté pour montrer sa profondeur dans la pile de #include.

-version

--version

Afficher le numéro de version de GNU CPP. Avec un tiret, continuer le prétraitement comme de coutume. Avec deux tirets, s'arrêter immédiatement.

Passer des options à l'assembleur

Vous pouvez passer des options à l'assembleur.

-Wa,option

Passer l'option à l'assembleur. Si option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules.

Options pour l'édition des liens

Ces options entre en jeu quand le compilateur lie des fichiers objets dans un fichier de sortie exécutable. Elles n'ont aucune signification si le compilateur n'effectue pas de phase d'édition des liens.

nom-fichier-objet

Un nom de fichier qui ne se termine pas par un suffixe spécial reconnu est supposé nommer un fichier objet ou une bibliothèque. (Les fichiers objets sont distingués des bibliothèques par l'éditeur de liens en fonction du contenu du fichier.) Si une phase d'édition des liens est effectuée, ces fichiers objets sont utilisés comme entrée pour l'éditeur de liens.

-c

-S

-E

Si une de ces options est utilisée, alors l'éditeur de liens n'est pas lancé, et les noms de fichiers objets ne devraient pas être utilisés comme arguments.

-lbibliothèque

-l bibliothèque

Rechercher la bibliothèque nommée bibliothèque lors de l'édition des liens. (La seconde alternative avec la bibliothèque spécifiée comme argument séparé n'est destinée qu'à la conformité POSIX et n'est pas recommandée.)

L'ordre d'écriture de cette option dans la ligne de commandes est important ; l'éditeur de liens recherche et traite les bibliothèques et les fichiers objets dans l'ordre dans lequel ils sont spécifiés. Donc, foo.o -lz bar.o recherche la bibliothèque z après le fichier foo.o mais avant bar.o. Si bar.o se réfère à des fonctions de z, ces fonctions ne peuvent être chargées.

L'éditeur de liens recherche la bibliothèque dans une liste standard de répertoires, bibliothèque qui est en fait un fichier s'appelant libbibliothèque.a. L'éditeur de liens utilise ensuite ce fichier comme s'il avait été spécifié précisément par son nom.

Les répertoires de recherche incluent divers répertoires standard du système, plus tous ceux que vous avez spécifiés avec -L.

Normalement, les fichiers trouvés de cette façon sont des fichiers de bibliothèque -- fichiers archives dont les membres sont des fichiers objets. L'éditeur de liens manipule un fichier archive en l'examinant pour trouver les membres qui ont déjà été référencés mais pas encore définis. Néanmoins, si l'éditeur de liens trouve un fichier objet ordinaire au lieu d'une bibliothèque, le fichier objet est lié de la façon habituelle. La seule différence entre utiliser une option -l et spécifier un nom de fichier est que -l entoure bibliothèque avec lib et .a et cherche dans plusieurs répertoires.

-lobjc

Vous avez besoin de ce cas particulier de l'option -l pour effectuer l'édition des liens d'un programme Objective-C.

-nostartfiles

Ne pas utiliser les fichiers de démarrage standard du système pendant l'édition des liens. Les bibliothèques standard sont utilisées normalement, à moins que -nostdlib ou -nodefaultlibs soit utilisé.

-nodefaultlibs

Ne pas utiliser les bibliothèques systèmes standard pendant l'édition de liens. Seules les bibliothèques que vous spécifiez seront passées à l'éditeur de liens. Les fichiers de démarrage standard sont utilisés normalement, à moins que -nostartfiles ne soit utilisé. Le compilateur peut générer des appels à memcmp, memset et memcpy pour les environnements System V (et C ISO), ou à bcopy et bzero pour les environnements BSD. Ces entrées sont habituellement résolues en entrées dans la libc. Ces points d'entrée devraient être fournis par un autre mécanisme quand cette option est spécifiée.

-nostdlib

Ne pas utiliser les fichiers de démarrage et les bibliothèques standard du système lors de l'édition de liens. Aucun fichier de démarrage et seules les bibliothèques que vous spécifiez seront passés à l'éditeur de liens. Le compilateur peut générer des appels à memcmp, memset et memcpy pour les environnements System V (et C ISO), ou à bcopy et bzero pour les environnements BSD. Ces entrées sont habituellement résolues en entrées dans la libc. Ces points d'entrée devraient être fournis par un autre mécanisme quand cette option est spécifiée.

Une des bibliothèques standard court-circuitée par -nostdlib et -nodefaultlibs est libgcc.a, une bibliothèque de sous-routines internes qu'utilise GCC pour surmonter les imperfections de machines particulières, ou pour des besoins spéciaux de certains langages.

Dans la plupart des cas, vous avez besoin de libgcc.a même si vous voulez éviter les autres bibliothèques standard. En d'autres termes, quand vous spécifiez -nostdlib ou -nodefaultlibs, vous devriez habituellement tout de même spécifier -lgcc. Cela permet d'assurer qu'il n'y a pas de références non résolues à des sous-routines de bibliothèque internes à GCC. (Par exemple __main, utilisé pour s'assurer que les constructeurs C++ seront appelés.)

-s

Supprimer toutes les informations concernant la table de symboles et les relogements de l'exécutable.

-static

Sur les systèmes supportant l'édition des liens dynamique, ceci empêche d'effectuer une édition de liens en utilisant des bibliothèques partagées. Sur les autres systèmes, cette option n'a aucun effet.

-shared

Produire un objet partagé qui peut être lié avec d'autres objets pour former un exécutable. Tous les systèmes ne supportent pas cette option. Pour obtenir des résultats prévisibles, vous devez également spécifier le même jeu d'options que celui qui a été utilisé pour générer le code (-fpic, -fPIC, ou des sous-options de modèles spécifiques) quand vous spécifiez cette option.[1]

-shared-libgcc

-static-libgcc

Sur les systèmes fournissant libgcc en tant que bibliothèque partagée, ces options forcent l'utilisation de la version partagée ou statique respectivement. Si aucune version partagée de libgcc n'a été construite quand le compilateur a été configuré, ces options n'ont pas d'effet.

Il y a plusieurs situations dans lesquelles une application devrait utiliser la libgcc partagée au lieu de la version statique. La plus habituelle d'entre elles est quand les applications veulent lancer et capturer des exceptions au travers de différentes bibliothèques partagées. Dans ce cas, chacune des bibliothèques ainsi que l'application elle-même devraient utiliser la libgcc partagée.

Par conséquent, les pilotes G++ et GCJ ajoutent automatiquement -shared-libgcc à chaque fois que vous construisez une bibliothèque partagée ou un exécutable principal, car les programmes C++ et Java utilisent typiquement les exceptions, et donc c'est la bonne chose à faire.

Si, par contre, vous utilisez le pilote GCC pour créer des bibliothèques partagées, vous pouvez vous rendre compte qu'elles ne seront pas toujours liées avec la libgcc partagée. Si GCC détecte, au moment de sa configuration, que vous disposez d'un éditeur de liens GNU qui ne supporte pas l'option --eh-frame-hdr, il liera la version partagée de libgcc aux bibliothèques partagées par défaut. Sinon, il tirera parti de l'éditeur de liens et supprimera l'optimisation de liaison avec la version partagée de libgcc, en liant avec la version statique de libgcc par défaut. Cela permet aux exceptions de se propager au travers de telles bibliothèques partagées, sans encourir de coûts de relogement au moment du chargement de la bibliothèque.

Néanmoins, si une bibliothèque ou l'exécutable principal est supposé(e) lancer ou capturer des exceptions, vous devez le (la) lier en utilisant le pilote G++ ou GCJ, de façon appropriée pour les langages utilisés dans le programme, ou en utilisant l'option -shared-libgcc, de sorte qu'il (elle) soit lié(e) avec la libgcc partagée.

-symbolic

Lier les références à des symboles globaux en construisant un objet partagé. Avertir des références non résolues (à moins que l'option ne soit surchargée par l'option de l'éditeur de liens -Xlinker -z -Xlinker defs). Seul un petit nombre de systèmes supportent cette option.

-Xlinker option

Passer l'option à l'éditeur de liens. Vous pouvez utiliser ceci pour fournir des options d'édition des liens spécifiques au système que GCC ne reconnaît pas.

Si vous voulez passer une option qui prend un argument, vous devez utiliser -Xlinker deux fois, la première pour l'option et la seconde pour l'argument. Par exemple, pour passer -assert definitions, vous devez écrire -Xlinker -assert -Xlinker definitions. Cela ne fonctionne pas d'écrire -Xlinker "-assert definitions", car cela passe la chaîne de caractères entière comme un seul argument, ce qui n'est pas ce à quoi s'attend l'éditeur de liens.

-Wl,option

Passer l'option à l'éditeur de liens. Si option contient des virgules, elle est découpée en de multiples options aux emplacements des virgules.

-u symbole

Prétendre que le symbole symbole est non défini, pour obliger la liaison avec les modules de bibliothèques pour le définir. Vous pouvez utiliser -u de multiples fois avec différents symboles pour forcer le chargement de modules de bibliothèques additionnels.

Options de recherche dans les répertoires

Ces options spécifient les répertoires où chercher les fichiers d'en-tête, les bibliothèques et les parties du compilateur :

-Irép

Ajouter le répertoire rép à la liste des répertoires où chercher les fichiers d'en-tête. Ceci peut être utilisé pour surcharger un fichier d'en-tête système, en le substituant par votre propre version, puisque ces répertoires sont parcourus avant les répertoires des fichiers d'en-tête système. Néanmoins, vous ne devriez pas utiliser cette option pour ajouter des répertoires contenant des fichiers d'en-tête système fournis par un vendeur (utilisez -isystem pour cela). Si vous utilisez plus d'une option -I, les répertoires sont examinés de gauche à droite ; les répertoires système standard viennent par après.

Si un répertoire d'inclusion système standard, ou un répertoire spécifié avec -isystem, est également spécifié avec -I, il ne sera parcouru que dans la position requise par -I. De plus, il ne sera pas considéré être un répertoire d'inclusion système. Si ce répertoire contient réellement des en-têtes système, il y a de fortes chances pour qu'ils soient détériorés. Par exemple, si la procédure d'installation de GCC a édité les en-têtes de /usr/include pour corriger des bogues, -I/usr/include trouvera les en-têtes originaux bogués au lieu des corrigés. GCC émettra un avertissement quand un répertoire d'inclusion système est masqué de cette manière.

-I-

Tous les répertoires spécifiés avec des options -I avant l'option -I- sont parcourus uniquement pour le cas des #include "fichier" ; ils ne sont pas parcourus pour des #include <fichier>.

Si des répertoires additionnels sont spécifiés par des options -I après le -I-, ces répertoires sont parcourus pour toutes les directives #include. (D'ordinaire tous les répertoires -I sont utilisés de cette façon.)

En plus, l'option -I- empêche l'utilisation du répertoire courant (où est situé le fichier d'entrée actuel) comme premier répertoire de recherche pour #include "fichier". Il n'y a aucune manière d'annuler cet effet de -I-. Avec -I., vous pouvez spécifier de chercher dans le répertoire qui était courant au moment de l'invocation du compilateur. Ce n'est pas exactement ce que fait le préprocesseur par défaut, mais c'est souvent satisfaisant.

-I- n'empêche pas l'utilisation des fichiers d'en-tête standard du système. Donc, -I- et -nostdinc sont indépendants.

-Lrép

Ajouter le répertoire rép à la liste des répertoires à parcourir pour les options -l.

-Bpréfixe

Cette option spécifie où trouver les exécutables, les bibliothèques, les fichiers inclus et les fichiers de données du compilateur lui-même.

Le programme pilote du compilateur lance un ou plusieurs des sous-programmes cpp, cc1, as ou ld. Il essaie d'utiliser préfixe comme préfixe pour chaque programme qu'il essaie de lancer, à la fois avec et sans machine/version/.

Pour chaque sous-programme à lancer, le pilote du compilateur essaie d'abord le préfixe -B, s'il est présent. Si ce nom n'est pas trouvé, ou si -B n'était pas spécifié, le pilote essaie deux préfixes standard, qui sont /usr/lib/gcc/ et /usr/local/lib/gcc-lib/. Si aucun des deux ne résulte en un nom de fichier qui est trouvé, le nom du programme non modifié est recherché en utilisant les répertoires spécifiés dans votre variable d'environnement PATH.

Le compilateur vérifiera si le chemin fourni par -B référence un répertoire et ajoutera si nécessaire un caractère séparateur de répertoires à la fin du chemin.

Les préfixes -B qui spécifient effectivement des noms de répertoires s'appliquent également aux bibliothèques de l'éditeur de liens, car le compilateur traduit ces options en options -L pour l'éditeur de liens. Ils s'appliquent également aux fichiers d'inclusion du préprocesseur, car le compilateur traduit ces options en options -isystem pour le préprocesseur. Dans ce cas, le compilateur concatène include au préfixe.

Le fichier de support à l'exécution libgcc.a peut également être recherché en utilisant le préfixe -B si nécessaire. S'il n'est pas trouvé ici, les deux préfixes standard ci-dessus sont essayés, et c'est tout. Le fichier n'est pas pris en compte lors de l'édition des liens s'il n'est pas trouvé d'une de ces façons.

Une autre façon de spécifier un préfixe similaire au préfixe -B est d'utiliser la variable d'environnement GCC_EXEC_PREFIX.

À titre d'exception, si le chemin fourni par -B est [rép/]stageN/, où N est un nombre dans l'intervalle 0 à 9, alors il sera remplacé par [rép/]include. Cela aide à l'amorçage du compilateur.

-specs=fichier

Traiter fichier après que le compilateur ait lu dans le fichier de specs standard, pour surcharger les « défauts » qu'utilise le programme pilote de gcc pour déterminer quels interrupteurs passer à cc1, cc1plus, as, ld, etc. Plus d'un -specs=fichier peut être spécifié sur la ligne de commandes, et ces options sont traitées dans l'ordre, de gauche à droite.

Spécifier la machine cible et la version du compilateur

Par défaut, GCC compile du code pour le même type de machine que celui que vous utilisez. Néanmoins, il peut également être installé comme compilateur croisé, pour compiler pour un autre type de machine. En fait, plusieurs configurations différentes de GCC, pour différentes machines cibles, peuvent être installées côte à côte. Ensuite, vous spécifiez laquelle utiliser avec l'option -b.

En plus, des anciennes et des nouvelles versions de GCC peuvent être installées côte à côte. L'une d'entre elles (probablement la plus récente) sera utilisée par défaut, mais vous pourriez également parfois devoir en utiliser une autre.

-b machine

L'argument machine spécifie la machine cible pour la compilation. Ceci est utile si vous avez installé GCC en tant que compilateur croisé.

La valeur à utiliser pour machine est la même que celle spécifiée au moment de la configuration de GCC comme compilateur croisé. Par exemple, si un compilateur croisé a été configuré avec configure i386v, signifiant compiler pour un 80386 faisant tourner System V, alors vous devrez spécifier -b i386v pour lancer ce compilateur croisé.

Quand vous ne spécifiez pas -b, cela signifie normalement que vous compilez pour le même type de machine que celui que vous utilisez.

-V version

L'argument version spécifie quelle version de GCC utiliser. C'est utile quand de multiples versions sont installées. Par exemple, version pourrait être 2.0, signifiant exécuter GCC version 2.0.

La version par défaut, quand vous ne spécifiez pas -V, est la dernière version de GCC que vous avez installée.

Les options -b et -V fonctionnent actuellement en contrôlant une partie du nom de fichier utilisé pour les fichiers exécutables, et des bibliothèques utilisées pour la compilation. Une version donnée de GCC, pour une machine cible donnée, est normalement conservée dans le répertoire /usr/local/lib/gcc-lib/machine/version.

Donc, des sites peuvent personnaliser l'effet de -b ou -V en changeant les noms de ces répertoires, ou en ajoutant des liens alternatifs (ou des liens symboliques). Si, dans le répertoire /usr/local/lib/gcc-lib/, le fichier 80386 est un lien vers le fichier i386v, alors -b 80386 devient un alias pour -b i386v.

Les options -b ou -V ne changent pas complètement d'un compilateur à l'autre ; le programme pilote haut-niveau de gcc que vous avez invoqué initialement continue à tourner et invoque les autres exécutables (préprocesseur, compilateur lui-même, assembleur et éditeur de liens) qui font le vrai boulot. Néanmoins, puisque aucun travail réel n'est effectué par le pilote du programme, cela importe généralement peu que le programme pilote utilisé ne soit pas celui pour la cible spécifiée. Il arrive souvent que l'interface vers d'autres exécutables change de façon incompatible entre différentes versions du compilateur, et donc, à moins que la version spécifiée ne soit très proche de celle du pilote (par exemple, -V 3.0 avec un programme pilote provenant de GCC version 3.0.1), l'utilisation de -V peut ne pas fonctionner ; par exemple, utiliser -V 2.95.2 ne fonctionnera pas avec un programme pilote provenant de GCC 3.0.

Le seul endroit où le programme pilote dépend de la machine cible se situe dans l'analyse grammaticale et le traitement des options spéciales spécifiques à une machine. Néanmoins, c'est contrôlé par un fichier qui est trouvé, avec les autres exécutables, dans le répertoire affecté aux version et machine cible spécifiées. Ainsi, un unique programme pilote installé s'adapte à n'importe quelle machine spécifié, et à des versions du compilateur suffisamment similaires.

L'exécutable du programme pilote contrôle néanmoins une chose importante : les version et machine cible par défaut. Donc, vous pouvez installer différentes instances du programme pilote, compilé pour différentes cibles ou versions, sous différents noms.

Par exemple, si le pilote pour la version 2.0 est installée en tant que ogcc et que la version 2.1 est installée en tant que gcc, alors la commande gcc utilisera la version 2.1 par défaut, alors que ogcc utilisera la 2.0 par défaut. Néanmoins, vous pouvez choisir l'une des versions en utilisant l'option -V.

Modèles matériels et configurations

Nous avons déjà discuté de l'option standard -b qui choisit entre différents compilateurs installés pour des machines cibles complètement différentes, comme VAX vs. 68000 vs. 80386.

En plus, chacune de ces types de machine cible peut disposer des ses propres options spéciales, débutant par -m, pour choisir entre plusieurs modèles matériels ou configurations -- par exemple, 68010 vs 68020, coprocesseur flottant ou non. Une version installée unique du compilateur peut compiler pour n'importe quel modèle ou configuration, en fonction des options spécifiées.

Certaines configurations du compilateur supportent également des options spéciales supplémentaires, habituellement pour la compatibilité avec d'autres compilateurs sur la même plate-forme.

Ces options sont définies par la macro de description de machine « TARGET_SWITCHES ». Les options par défaut sont également définies par cette macro, ce qui vous permet de modifier les valeurs par défaut.

Options M680x0

Voici les options -m définies pour les séries 68000. Les valeurs par défaut pour ces options dépendent du style de 68000 qui a été sélectionné quand le compilateur a été configuré ; les valeurs par défaut pour la plupart des choix sont données ci-dessous.

-m68000

-mc68000

Générer une sortie pour un 68000. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68000.

Utilisez cette option pour les microcontrôleurs possédant un coeur 68000 ou EC000, ce qui inclut les 68008, 68302, 68306, 68307, 68322, 68328 et les 68356.

-m68020

-mc68020

Générer une sortie pour un 68020. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68020.

-m68881

Générer une sortie contenant des instructions 68881 instructions pour flottants. C'est le comportement par défaut pour la plupart des systèmes à base de 68020 à moins que --nfp n'ait été spécifié lors de la configuration du compilateur.

-m68030

Générer une sortie pour un 68030. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68030.

-m68040

Générer une sortie pour un 68040. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68040.

Cette option interdit l'utilisation des instructions 68881/68882 qui doivent être émulées de façon logicielle sur les 68040. Utilisez cette option si votre 68040 ne possède pas de code permettant d'émuler ces instructions.

-m68060

Générer une sortie pour un 68060. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68060.

Cette option interdit l'utilisation d'instructions 68881/68882 qui doivent être émulées par logiciel sur les 68060. Utilisez cette option si votre 68060 ne possède pas de code pour émuler ces instructions.

-mcpu32

Générer une sortie pour un CPU32. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de CPU32.

Utilisez cette option pour les microcontrôleurs possédant un coeur CPU32 ou CPU32+, ce qui inclut les 68330, 68331, 68332, 68333, 68334, 68336, 68340, 68341, 68349 et les 68360.

-m5200

Générer une sortie pour un processeur de la famille 520X « coldfire ». C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 520X.

Utilisez cette option pour les microcontrôleurs possédant un coeur 5200, ce qui inclut les MCF5202, MCF5203, MCF5204 et les MCF5202.

-m68020-40

Générer une sortie pour un 68040, sans utiliser une seule des nouvelles instructions. Ceci résulte en un code qui peut tourner relativement efficacement sur un 68020/68881, un 68030 ou encore un 68040. Le code généré utilise les instructions 68881 qui sont émulées sur le 68040.

-m68020-60

Générer une sortie pour un 68060, sans utiliser une seule des nouvelles instructions. Ceci résulte en un code qui peut tourner relativement efficacement sur un 68020/68881, un 68030 ou encore un 68040. Le code généré utilise les instructions 68881 qui sont émulées sur le 68060.

-mfpa

Générer une sortie contenant des instructions Sun FPA pour flottants.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : Les bibliothèques requises ne sont pas disponibles pour toutes les cibles m68k. Normalement, les facilités offertes par le compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. Les cibles embarquées m68k-*-aout et m68k-*-coff fournissent un support logiciel des flottants.

-mshort

Considérer que le type « int » a 16 bits de largeur, comme « short int ».

-mnobitfield

Ne pas utiliser les instructions utilisant des champs-bits. Les options -m68000, -mcpu32 et -m5200 impliquent -mnobitfield.

-mbitfield

Utiliser les instructions utilisant des champs-bits. L'option -m68020 implique -mbitfield. C'est le comportement par défaut si vous utilisez une configuration prévue pour un 68020.

-mrtd

Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant avec l'instruction « rtd », qui dépile ses arguments en sortant. Ceci fait économiser une instruction à l'appelant qui ne doit alors pas dépiler les arguments.

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

De plus, vous devez fournir des prototypes de fonction pour toutes les fonctions qui prennent un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En outre, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

L'instruction « rtd » est supportée par les processeurs 68010, 68020, 68030, 68040, 68060 et CPU32, mais pas par le 68000 ou le 5200.

-malign-int

-mno-align-int

Contrôler si GCC aligne les variables « int », « long », « long long », « float », « double » et « long double » à des limites de 32 bits (-malign-int) ou à des limites de 16 bits (-mno-align-int). L'alignement des variables à des limites de 32 bits produit du code tournant légèrement plus rapidement sur des processeurs possédant des bus 32 bits, aux dépens d'une plus grosse consommation mémoire.

Avertissement : si vous utilisez l'interrupteur -malign-int, GCC alignera les structures contenant les types cités ci-dessus différemment de la plupart des spécifications d'interface binaire applicative (ABI) pour le m68k.

-mpcrel

Utiliser le mode d'adressage relatif au p.c. du 68000 directement, au lieu d'utiliser une table de décalage globale. Actuellement, cette option implique -fpic, permettant un décalage d'au plus 16 bits pour l'adressage relatif au p.c. -fPIC n'est pas actuellement supporté avec -mpcrel, bien que cela puisse se faire pour les processeurs 68020 et supérieurs.

-mno-strict-align

-mstrict-align

Ne pas permettre (permettre) que des références mémoire non alignées soient traitées par le système.

Options M68hc1x

Voici les options -m définies pour les microcontrôleurs 68hc11 et 68hc12. Les valeurs par défaut pour ces options dépendent du style de microcontrôleur qui a été sélectionné quand le compilateur a été configuré ; les valeurs par défaut pour la plupart des choix sont données ci-dessous.

-m6811

-m68hc11

Générer une sortie pour un 68HC11. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68HC11.

-m6812

-m68hc12

Générer une sortie pour un 68HC12. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 68HC12.

-mauto-incdec

Activer l'utilisation des modes d'adressage de pré et post auto-incrémentation du 68HC12.

-mshort

Considérer que le type « int » a 16 bits de largeur, comme « short int ».

-msoft-reg-count=nombre

Spécifier le nombre de pseudo-registres logiciels qui sont utilisés pour la génération de code. Le nombre maximum est de 32. L'utilisation de plus de pseudo-registres logiciels peut résulter ou non en un meilleur code en fonction du programme. La valeur par défaut est 4 pour le 68HC11 et 2 pour le 68HC12.

Options VAX

Ces options -m sont définies pour le VAX :

-munix

Ne pas produire certaines instructions de saut (« aobleq » etc.) que l'assembleur Unix pour VAX ne peut traiter sur une grande portée.

-mgnu

Produire ces instructions de saut, en supposant que vous assemblerez avec l'assembleur GNU.

-mg

Produire du code pour le format g des nombres flottants au lieu du format d.

Options SPARC

Ces interrupteurs -m sont supportés sur la SPARC:

-mno-app-regs

-mapp-regs

Spécifiez -mapp-regs pour générer une sortie qui utilise les registres globaux 2 à 4, qui sont réservés par l'ABI SPARC SVR4 pour les applications. C'est le comportement par défaut.

Pour être totalement conforme à l'ABI SVR4 au prix d'une certaine perte de performance, spécifiez -mno-app-regs. Vous devriez compiler les bibliothèques et les logiciels système avec cette option.

-mfpu

-mhard-float

Générer une sortie contenant des instructions flottantes.

-mno-fpu

-msoft-float

Générer une sortie contenant les appels de bibliothèque pour flottants. Attention : les bibliothèques requises ne sont pas disponibles pour toutes les cibles SPARC. Normalement, les facilités offertes par le compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. Les cibles embarquées sparc-*-aout et sparclite-*-* fournissent un support logiciel des flottants.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

-mhard-quad-float

Générer une sortie contenant des instructions flottantes utilisant des quads (mots « quadruples », soit long double).

-msoft-quad-float

Générer une sortie contenant des appels de bibliothèque pour les instructions flottantes utilisant des quads (long double). Les fonctions appelées sont celles spécifiées dans l'ABI SPARC. C'est le comportement par défaut.

Au moment de l'écriture de cette page de manuel, il n'existe aucune implémentation sparc qui possède un support matériel pour les instructions flottantes utilisant des quads. Elles invoquent toutes un gestionnaire d'interruptions pour une de ces instructions, et ensuite le gestionnaire d'interruptions émule l'effet de l'instruction. À cause de la surcharge due au gestionnaire d'interruptions, ceci est beaucoup plus lent que d'appeler les routines de la bibliothèque ABI. L'option -msoft-quad-float est donc utilisée par défaut.

-mno-flat

-mflat

Avec -mflat, le compilateur ne génère pas d'instructions save/restore (sauver/restaurer) et utilisera une convention d'appel « plate » ou à fenêtre d'un registre. Ce modèle utilise %i7 comme pointeur de cadre et est compatible avec le modèle normal de fenêtre de registres. Les code de chacun d'entre eux peuvent être entremêlés. Les registres locaux et les registres d'entrée (0--5) sont toujours traités comme des registres « sauvés lors de l'appel » et seront sauvés sur la pile si nécessaire.

Avec -mno-flat (utilisée par défaut), le compilateur émet des instructions save/restore (sauf pour les fonctions feuilles) et est le mode de fonctionnement normal.

-mno-unaligned-doubles

-munaligned-doubles

Supposer que les doubles ont un alignement de 8 octets. C'est le comportement par défaut.

Avec -munaligned-doubles, GCC suppose que les doubles n'ont un alignement de 8 octets que s'ils sont contenus dans un autre type, ou s'ils ont une adresse absolue. Sinon, il suppose qu'ils ont un alignement de 4 octets. Spécifier cette option évite quelques rares problèmes de compatibilité avec du code généré par d'autres compilateurs. Ce n'est pas le comportement par défaut car cela résulte en une baisse de performance, spécialement pour le code flottant.

-mno-faster-structs

-mfaster-structs

Avec -mfaster-structs, le compilateur suppose que les structures devraient avoir un alignement de 8 octets. Cela permet l'utilisation de paires d'instructions « ldd » et « std » pour les copies dans l'affectation de structures, au lieu du double de paires « ld » et « st ». Néanmoins, l'utilisation de cet alignement modifié viole directement l'ABI Sparc. Ce n'est donc prévu que pour être utilisé sur des cibles où le développeur admet que son code résultant ne sera pas directement en ligne avec les règles de l'ABI.

-mv8

-msparclite

Ces deux options sélectionnent des variantes de l'architecture SPARC.

Par défaut (à moins d'être spécialement configuré pour la SPARClite Fujitsu), GCC génère du code pour la variante v7 de l'architecture SPARC.

-mv8 vous fournira du code SPARC v8. La seule différence avec le code v7 est que le compilateur émet les instructions de multiplication et de division entières qui existent dans SPARC v8 mais pas dans SPARC v7.

-msparclite vous fournira du code SPARClite. Cela ajoute les instructions de multiplication entière, de « integer divide step and scan (ffs) » qui existent sur la SPARClite mais pas sur la SPARC v7.

Ces options sont dépréciées et seront supprimées dans une future version de GCC. Elles ont été remplacées par -mcpu=xxx.

-mcypress

-msupersparc

Ces deux options sélectionnent le processeur pour lequel le code est optimisé.

Avec -mcypress (le processeur par défaut), le compilateur optimise le code pour la puce Cypress CY7C602, qui est utilisée dans les séries SparcStation/SparcServer 3xx, ainsi que pour les plus anciennes SparcStation 1, 2, IPX etc.

Avec -msupersparc, le compilateur optimise le code pour le processeur SuperSparc, qui est utilisé dans les séries SparcStation 10, 1000 et 2000. Ce drapeau active également l'utilisation du jeu d'instructions complet SPARC v8.

Ces options sont dépréciées et seront supprimées dans une future version de GCC. Elles ont été remplacées par -mcpu=xxx.

-mcpu=type-cpu

Fixer le jeu d'instructions, le jeu de registres et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont v7, cypress, v8, supersparc, sparclite, hypersparc, sparclite86x, f930, f934, sparclet, tsc701, v9 et ultrasparc.

Les paramètres d'ordonnancement des instructions par défaut sont utilisés pour les valeurs qui sélectionnent une architecture et pas une implémentation. Ce sont v7, v8, sparclite, sparclet, v9.

Voici une liste de chaque architecture supportée et de leurs implémentations supportées :

            v7 :             cypress
            v8 :             supersparc, hypersparc
            sparclite :      f930, f934, sparclite86x
            sparclet  :      tsc701
            v9 :             ultrasparc
    

-mtune=type-cpu

Fixer les paramètres d'ordonnancement des instructions pour le type de machine type-cpu, mais ne pas fixer le jeu d'instructions ou le jeu de registres comme le ferait l'option -mcpu=type-cpu.

Les mêmes valeurs pour -mcpu=type-cpu peuvent être utilisées pour -mtune=type-cpu, mais les seules valeurs utiles sont celles qui sélectionnent une implémentation de cpu particulière. Ce sont cypress, supersparc, hypersparc, f930, f934, sparclite86x, tsc701 et ultrasparc.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus pour le processeur SPARCLET.

-mlittle-endian

Générer du code pour un processeur tournant en mode petit-boutiste.

-mlive-g0

Traiter le registre « %g0 » comme un registre normal. GCC continuera à le corrompre si nécessaire mais ne supposera pas qu'il vaut toujours 0.

-mbroken-saverestore

Générer du code qui n'utilise pas des formes non triviales des instructions « save » et « restore ». Des versions anciennes du processeur SPARCLET ne traitent pas correctement les instructions « save » et « restore » utilisées avec des arguments. Elles les traitent correctement sans argument. Une instruction « save » utilisée sans argument incrémente le pointeur de fenêtre actuel mais n'alloue pas de nouveau pointeur de pile. On suppose que le gestionnaire d'interruptions du débordement de fenêtre traitera correctement ce cas comme le feraient les gestionnaires d'interruptions.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus pour les processeurs SPARC V9 dans les environnements 64 bits.

-mlittle-endian

Générer du code pour un processeur tournant en mode petit-boutiste.

-m32

-m64

Générer du code pour un environnement 32 ou 64 bits respectivement. L'environnement 32 bits établit les int, long et pointeurs à 32 bits. L'environnement 64 bits établit les int à 32 bits et les long et les pointeurs à 64 bits.

-mcmodel=medlow

Générer du code pour le modèle de code Medium/Low : le programme doit être lié dans les 32 bits bas de l'espace d'adressage. Les pointeurs ont 64 bits. Les programmes peuvent subir une édition de liens statique ou dynamique.

-mcmodel=medmid

Générer du code pour le modèle de code Medium/Middle : le programme doit être lié dans les 44 bits inférieurs de l'espace d'adressage, le segment de texte doit occuper moins de 2 Go, et le segment de données doit se situer à l'intérieur des 2 Go du segment de texte. Les pointeurs font 64 bits.

-mcmodel=medany

Générer du code pour le modèle de code Medium/Anywhere : le programme peut être lié n'importe où dans l'espace d'adressage, le segment de texte doit occuper moins de 2 Go, et le segment de données doit se situer à l'intérieur des 2 Go du segment de texte. Les pointeurs font 64 bits.

-mcmodel=embmedany

Générer du code pour le modèle de code Medium/Anywhere pour les systèmes embarqués : supposer un segment de texte 32 bits et un segment de données 32 bits, les deux débutant n'importe où (déterminé au moment de l'édition des liens). Le registre %g4 pointe sur la base du segment de données. Les pointeurs font toujours 64 bits. Les programmes sont liés statiquement, le PIC (code indépendant de la position) n'est pas supporté.

-mstack-bias

-mno-stack-bias

Avec -mstack-bias, GCC suppose que le pointeur de pile, et le pointeur de cadre s'il existe, sont décalés de -2047 qui doit être rajouté lors de la création de références au cadre de pile. Sinon, supposer qu'aucun décalage de la sorte n'est présent.

Options Convex

Ces options -m sont définies pour le Convex:

-mc1

Générer une sortie pour C1. Le code tournera sur n'importe quelle machine Convex. Le symbole de préprocesseur « __convex__c1__ » est défini.

-mc2

Générer une sortie pour C2. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C2. Le symbole de préprocesseur « __convex__c2__ » est défini.

-mc32

Générer une sortie pour C32xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C32. Le symbole de préprocesseur « __convex__c32__ » est défini.

-mc34

Générer une sortie pour C34xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C34. Le symbole de préprocesseur « __convex__c34__ » est défini.

-mc38

Générer une sortie pour C38xx. Utilise des instructions non disponibles sur C1. L'ordonnancement et d'autres optimisations sont choisis pour obtenir une performance maximale sur C38. Le symbole de préprocesseur « __convex__c38__ » est défini.

-margcount

Générer du code qui place un compte du nombre d'arguments dans le mot précédant chaque liste d'arguments. C'est compatible avec le CC habituel, et certains programmes peuvent avoir besoin du mot de comptage d'arguments. GDB et d'autres débogueurs de niveau source n'en ont pas besoin ; cette info se trouve dans la table des symboles.

-mnoargcount

Omettre le mot de comptage d'arguments. C'est le comportement par défaut.

-mvolatile-cache

Permettre aux références volatiles d'être mises en cache. C'est le comportement par défaut.

-mvolatile-nocache

Les références volatiles contournent le cache de données, allant directement en mémoire. Ce n'est nécessaire que pour du code multi-processeurs qui n'utilise pas d'instructions standard de synchronisation. Créer des références non volatiles vers des emplacements volatils ne fonctionnera pas nécessairement.

-mlong32

Le type long fait 32 bits, le même que le type int. C'est le comportement par défaut.

-mlong64

Le type long fait 64 bits, le même que le type long long. Cette option est inutile, car aucun support de bibliothèque n'existe pour elle.

Options AMD29K

Ces options -m sont définies pour l'AMD Am29000:

-mdw

Générer du code qui suppose que le bit « DW » est positionné, c.-à-d. que les opérations sur les octets et les demi-mots sont directement supportées par le matériel. C'est le comportement par défaut.

-mndw

Générer du code qui suppose que le bit « DW » n'est pas positionné.

-mbw

Générer du code qui suppose que le système supporte les opérations d'écriture d'octet et de demi-mot. C'est le comportement par défaut.

-mnbw

Générer du code qui suppose que les systèmes ne supportent pas les opérations d'écriture d'octet et de demi-mot. -mnbw implique -mndw.

-msmall

Utiliser un modèle de mémoire restreint qui suppose que toutes les adresses de fonction sont ou bien dans un seul segment de 256 Ko, ou bien à une adresse absolue de moins de 256 Ko. Cela permet à l'instruction « call » d'être utilisée au lieu d'une séquence « const », « consth », « calli ».

-mnormal

Utiliser le modèle de mémoire normal : générer des instructions « call » uniquement quand les fonctions appelantes sont dans le même fichier, et des instructions « calli » sinon. Cela fonctionne si chaque fichier occupe moins de 256 Ko mais permet à l'exécutable entier d'être plus grand que 256 Ko. C'est le comportement par défaut.

-mlarge

Toujours utiliser des instructions « calli ». Spécifiez cette option si vous vous attendez à ce qu'un seul fichier se compile en plus de 256 Ko de code.

-m29050

Générer du code pour l'Am29050.

-m29000

Générer du code pour l'Am29000. C'est le comportement par défaut.

-mkernel-registers

Générer des références aux registres « gr64-gr95 » plutôt qu'aux registres « gr96-gr127 ». Cette option peut être utilisée lors de la compilation d'un noyau qui veut un ensemble de registres globaux disjoint de celui utilisé par le code en mode utilisateur.

Notez que quand cette option est utilisée, les noms de registres dans les drapeaux -f doivent utiliser les noms normaux en mode utilisateur.

-muser-registers

Utiliser l'ensemble normal de registres globaux, « gr96-gr127 ». C'est le comportement par défaut.

-mstack-check

-mno-stack-check

Insérer (ne pas insérer) un appel à « __msp_check » après chaque ajustement de pile. C'est souvent utilisé dans le code du noyau.

-mstorem-bug

-mno-storem-bug

-mstorem-bug s'occupe des processeurs 29k qui ne peuvent traiter la distinction entre une instruction mtsrim et une instruction storem (la plupart des puces 29000 à l'heure actuelle, mais pas la 29050).

-mno-reuse-arg-regs

-mreuse-arg-regs

-mno-reuse-arg-regs indique au compilateur de n'utiliser que les registres des arguments d'entrée pour les arguments de sortie. Cela aide à détecter une fonction avec moins d'arguments que le nombre présent dans sa déclaration.

-mno-impure-text

-mimpure-text

-mimpure-text, utilisé en plus de -shared, indique au compilateur de ne pas passer -assert pure-text à l'éditeur de liens lors de la liaison d'un objet partagé.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

-mno-multm

Ne pas générer d'instructions multm ou multmu. C'est utile pour certains systèmes embarqués qui ne possèdent pas de gestionnaire d'interruptions pour ces instructions.

Options ARM

Ces options -m sont définies pour les architectures Advanced RISC Machines (ARM) :

-mapcs-frame

Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure ARM pour toutes les fonctions, même si ce n'est pas strictement nécessaire pour une correcte exécution du code. Spécifier -fomit-frame-pointer avec cette option empêchera la génération de cadres de pile pour les fonctions feuilles. -mno-apcs-frame est utilisé par défaut.

-mapcs

C'est un synonyme pour -mapcs-frame.

-mapcs-26

Générer du code pour un processeur fonctionnant avec un indicateur d'instruction courante de 26 bits, et se conformant aux standards d'appel de fonction pour l'option APCS 26 bits. Cette option remplace les options -m2 et -m3 de précédentes versions du compilateur.

-mapcs-32

Générer du code pour un processeur fonctionnant avec un indicateur d'instruction courante de 32 bits, et se conformant aux standards d'appel de fonction pour l'option APCS 32 bits. Cette option remplace l'option -m6 de précédentes versions du compilateur.

-mthumb-interwork

Générer du code qui supporte l'appel entre les jeux d'instructions ARM et Thumb. Sans cette option, les deux jeux d'instructions ne peuvent être utilisés fiablement dans un programme. L'option par défaut est -mno-thumb-interwork, puisqu'un code légèrement plus gros est généré quand -mthumb-interwork est spécifié.

-mno-sched-prolog

Empêcher le réordonnancement des instructions du prologue de la fonction, ou la fusion de ces instructions avec des instructions du corps de la fonction. Cela signifie que toutes les fonctions commenceront par une suite d'instructions reconnaissable (ou en fait une choisie parmi un petit ensemble de différents prologues de fonction), et cette information peut être utilisée pour localiser le début si des fonctions sont à l'intérieur d'un morceau de code exécutable. -msched-prolog est utilisé par défaut.

-mhard-float

Générer une sortie contenant des instructions flottantes. C'est le comportement par défaut.

-msoft-float

Générer une sortie contenant des appels de bibliothèques pour flottants. Avertissement : les bibliothèques requises ne sont pas disponibles pour toutes les cibles ARM. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

-mlittle-endian

Générer du code pour un processeur tournant en mode petit-boutiste. C'est le comportement par défaut pour toutes les configurations standard.

-mbig-endian

Générer du code pour un processeur tournant en mode gros-boutiste. Le comportement par défaut est de compiler du code pour un processeur petit-boutiste.

-mwords-little-endian

Cette option ne s'applique que lors de la génération de code pour des processeurs gros-boutistes. Générer du code pour un ordre des mots petit-boutiste, mais pour un ordre des octets gros-boutistes, c.-à-d. un ordre d'octets de la forme 32107654. Note : cette option ne devrait être utilisée que si vous avez besoin de la compatibilité avec du code pour des processeurs ARM gros-boutistes généré par des versions du compilateur antérieures à 2.8.

-malignment-traps

Générer du code qui ne provoquera pas d'interruption si le MMU a activé les interruptions d'alignement. Sur les architectures ARM antérieures à ARMv4, il n'existait pas d'instruction permettant d'accéder à des objets de taille d'un demi-mot stockés en mémoire. Néanmoins, quand on lit quelque chose de la mémoire, une fonctionnalité de l'architecture ARM permet d'utiliser un chargement d'un mot, même si l'adresse n'est pas alignée, et le coeur du processeur fera tourner (rotate) les données pendant leur chargement. Cette option indique au compilateur que de tels accès mal alignés provoqueront une interruption MMU et qu'il devrait au lieu de cela synthétiser les accès en une série d'accès octets. Le compilateur peut toujours utiliser des accès mots pour charger des données d'un demi-mot s'il sait que l'adresse est alignée à une limite de mot.

Cette option est ignorée lors de la compilation pour l'architecture ARM 4 ou suivantes, puisque ces processeurs disposent d'instructions permettant d'accéder directement à des objets d'un demi-mot en mémoire.

-mno-alignment-traps

Générer du code qui suppose que le MMU ne provoquera pas d'interruption en cas d'accès non aligné. Cela produit un meilleur code quand le jeu d'instructions cible ne possède pas d'opérations mémoire sur les demi-mots (c.-à-d. des implémentations antérieures à ARMv4).

Notez que vous ne pouvez pas utiliser cette option pour accéder à des objets mots non alignés, car le processeur n'ira quérir qu'un objet de 32 bits aligné de la mémoire.

Le réglage par défaut sur la plupart des cibles est -mno-alignment-traps, puisque cela produit du meilleur code quand il n'y a pas d'instructions mémoire disponibles pour les demi-mots.

-mshort-load-bytes

-mno-short-load-words

Ce sont des synonymes dépréciés pour -malignment-traps.

-mno-short-load-bytes

-mshort-load-words

Ce sont des synonymes dépréciés pour -mno-alignment-traps.

-mbsd

Cette option s'applique uniquement au RISC iX. Émuler le compilateur natif du mode BSD. C'est le comportement par défaut si -ansi n'est pas spécifié.

-mxopen

Cette option s'applique uniquement au RISC iX. Émuler le compilateur natif du mode X/Open.

-mno-symrename

Cette option s'applique uniquement au RISC iX. Ne pas lancer le post-processeur de l'assembleur, symrename, après que le code ait été assemblé. Il est normalement nécessaire de modifier certains symboles standard en préparation de l'édition des liens avec la bibliothèque C RISC iX ; cette option supprime cette passe. Le post-processeur n'est jamais exécuté quand le compilateur est construit pour la compilation croisée.

-mcpu=nom

Ceci spécifie le nom du processeur ARM cible. GCC utilise ce nom pour déterminer quel type d'instructions il peut émettre lors de la génération de code assembleur. Les noms autorisés sont : arm2, arm250, arm3, arm6, arm60, arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700, arm700i, arm710, arm710c, arm7100, arm7500, arm7500fe, arm7tdmi, arm8, strongarm, strongarm110, strongarm1100, arm8, arm810, arm9, arm9e, arm920, arm920t, arm940t, arm9tdmi, arm10tdmi, arm1020t et xscale.

-mtune=nom

Cette option est très similaire à l'option -mcpu=, sauf qu'au lieu de spécifier le type de processeur cible réel, et donc restreindre les instructions pouvant être utilisées, il spécifie que GCC devrait ajuster la performance du code comme si la cible était du type spécifié dans cette option, mais devra toujours choisir les instructions qu'il va générer en fonction du processeur spécifié par une option -mcpu=. Pour certaines implémentations ARM, une meilleure performance peut être obtenue en utilisant cette option.

-march=nom

Ceci spécifie le nom de l'architecture ARM cible. GCC utilise ce nom pour déterminer quel type d'instructions il peut émettre lors de la génération de code assembleur. Cette option peut être utilisée en conjonction avec, ou sans l'option -mcpu=. Les noms autorisés sont : armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5te.

-mfpe=nombre

-mfp=nombre

Cela spécifie la version de l'émulation flottante disponible sur la cible. Les valeurs permises sont 2 et 3. -mfp= est un synonyme pour -mfpe=, dans un but de compatibilité avec des versions plus anciennes de GCC.

-mstructure-size-boundary=n

La taille de toutes les structures et unions sera arrondie vers le haut à un multiple du nombre de bits fixés par cette option. Les valeurs permises sont 8 et 32. La valeur par défaut varie pour différentes chaînes d'outils. Pour la chaîne d'outils destinée à COFF, la valeur par défaut est 8. Spécifier le plus grand nombre peut produire du code plus rapide, plus efficace, mais peut également augmenter la taille du programme. Les deux valeurs sont potentiellement incompatibles. Du code compilé avec une valeur ne fonctionnera pas forcément avec du code ou des bibliothèques compilés avec l'autre valeur, s'ils s'échangent des informations en utilisant des structures ou des unions.

-mabort-on-noreturn

Générer un appel à la fonction « abort » à la fin d'une fonction « noreturn ». Il sera exécuté si la fonction essaie de revenir à l'appelant.

-mlong-calls

-mno-long-calls

Indiquer au compilateur d'effectuer des appels de fonction en chargeant d'abord l'adresse de la fonction dans un registre, et en effectuant ensuite un appel de sous-routine sur ce registre. Cet interrupteur est nécessaire si la fonction cible se trouvera au-delà des 64 mégaoctets de possibilité d'adressage de l'instruction d'appel de sous-routine basée sur un décalage.

Même si cet interrupteur est activé, tous les appels de fonction ne seront pas transformés en appels longs. L'heuristique est que les fonctions statiques, les fonctions possédant l'attribut short-call, les fonctions situées à l'intérieur de la portée d'une directive #pragma no_long_calls, et les fonctions dont les définitions ont déjà été compilées à l'intérieur de l'unité de compilation courante ne seront pas converties en appels longs. L'exception à cette règle est que les définitions de fonction faibles, les fonctions possédant l'attribut long-call ou l'attribut section, et les fonctions situées à l'intérieur de la portée d'une directive #pragma long_calls, seront toujours transformées en appels longs.

Cette fonctionnalité n'est pas activée par défaut. Spécifier -mno-long-calls restaurera le comportement par défaut, comme le fait de placer les appels de fonction dans la portée d'une directive #pragma long_calls_off. Notez que ces interrupteurs n'ont aucun effet sur la façon dont le compilateur génère du code pour traiter les appels de fonction via des pointeurs de fonction.

-mnop-fun-dllimport

Désactiver le support de l'attribut « dllimport ».

-msingle-pic-base

Traiter le registre utilisé pour l'adressage PIC comme étant en lecture seule, plutôt que de le charger dans le prologue pour chaque fonction. Le système d'exécution est responsable de l'initialisation de ce registre avec une valeur appropriée avant que l'exécution ne débute.

-mpic-register=reg

Spécifier le registre à utiliser pour l'adressage PIC. Celui par défaut est R10 à moins que la vérification de la pile ne soit activée, quand R9 est utilisé.

-mpoke-function-name

Écrire le nom de chaque fonction dans la section de texte, précédant directement le prologue de la fonction. Le code généré est similaire à ceci :

             t0
                 .ascii "arm_poke_function_name", 0
                 .align
             t1
                 .word 0xff000000 + (t1 - t0)
             arm_poke_function_name
                 mov     ip, sp
                 stmfd   sp!, {fp, ip, lr, pc}
                 sub     fp, ip, #4
    

Quand on génère une pile d'appels, le code peut examiner la valeur de « pc » stockée en « fp + 0 ». Si la fonction de trace regarde ensuite à l'emplacement « pc - 12 » et que les 8 bits supérieurs sont positionnés, alors on sait qu'il y a un nom de fonction imbriquée précédant immédiatement cet emplacement, et de longueur « ((pc[-3]) & 0xff000000) ».

-mthumb

Générer du code pour le jeu d'instructions Thumb 16 bits. Le comportement par défaut est d'utiliser le jeu d'instructions ARM 32 bits.

-mtpcs-frame

Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure Thumb pour toutes les fonctions non feuilles. (Une fonction feuille est une fonction qui n'appelle aucune autre fonction). Le défaut est -mno-tpcs-frame.

-mtpcs-leaf-frame

Générer un cadre de pile qui est conforme au Standard d'Appel de Procédure Thumb pour toutes les fonctions feuilles. (Une fonction feuille est une fonction qui n'appelle aucune autre fonction). Le défaut est -mno-apcs-leaf-frame.

-mcallee-super-interworking

Donner à toutes les fonctions visibles en dehors du fichier en cours de compilation un en-tête de jeu d'instructions ARM qui passe dans le mode Thumb avant d'exécuter le reste de la fonction. Cela permet à ces fonctions d'être appelées à partir de code non-interfonctionnel.

-mcaller-super-interworking

Permettre aux appels via des pointeurs de fonction (incluant les fonctions virtuelles) de s'exécuter correctement que le code cible ait été compilé pour l'interfonctionnalité ou pas. Si cette option est activée, il en résulte une légère surcharge lors de l'exécution d'un pointeur de fonction.

Options MN10200

Ces options -m sont définies pour les architectures Matsushita MN10200 :

-mrelax

Indiquer à l'éditeur de liens qu'il doit effectuer une passe d'optimisation de relaxation pour raccourcir les branchements, les appels et les adresses mémoire absolues. Cette option n'a d'effet que lorsqu'elle est utilisée sur la ligne de commandes au moment de l'étape finale de l'édition des liens.

Cette option empêche le débogage symbolique.

Options MN10300

Ces options -m sont définies pour les architectures Matsushita MN10300 :

-mmult-bug

Générer du code pour éviter les bogues dans les instructions de multiplication des processeurs MN10300. Utilisé par défaut.

-mno-mult-bug

Ne pas générer de code pour éviter les bogues dans les instructions de multiplication des processeurs MN10300.

-mam33

Générer du code qui utilise des fonctionnalités spécifiques au processeur AM33.

-mno-am33

Ne pas générer de code qui utilise des fonctionnalités spécifiques au processeur AM33. Utilisé par défaut.

-mno-crt0

Ne pas lier dans le fichier objet C d'initialisation à l'exécution.

-mrelax

Indiquer à l'éditeur de liens qu'il doit effectuer une passe d'optimisation de relaxation pour raccourcir les branchements, les appels et les adresses mémoire absolues. Cette option n'a d'effet que lorsqu'elle est utilisée sur la ligne de commandes au moment de l'étape finale de l'édition des liens.

Cette option interdit tout débogage symbolique.

Options M32R/D

Ces options -m sont définies pour les architectures Mitsubishi M32R/D :

-m32rx

Générer du code pour le M32R/X.

-m32r

Générer du code pour le M32R. Utilisé par défaut.

-mcode-model=small

Supposer que tous les objets résident à l'intérieur des 16 Mo inférieurs de mémoire (de sorte que leurs adresses puissent être chargées avec l'instruction « ld24 »), et supposer que toutes les sous-routines sont accessibles par l'instruction « bl ». C'est le comportement par défaut.

L'adressabilité d'un objet particulier peut être fournie via l'attribut « modèle ».

-mcode-model=medium

Supposer que les objets peuvent se situer n'importe où dans l'espace d'adressage 32 bits (le compilateur générera des instructions « seth/add3 » pour charger leurs adresses), et supposer que toutes les sous-routines sont accessibles par l'instruction « bl ».

-mcode-model=large

Supposer que les objets peuvent se situer n'importe où dans l'espace d'adressage 32 bits (le compilateur générera des instructions « seth/add3 » pour charger leurs adresses), et supposer que les sous-routines ne peuvent pas être accessibles par l'instruction « bl » (le compilateur générera la séquence d'instructions beaucoup plus lente « seth/add3/jl »).

-msdata=none

Désactiver l'utilisation de la petite zone de données. Les variables seront placées dans .data, bss ou .rodata (à moins que l'attribut « section » n'ait été spécifié). C'est le comportement par défaut.

La petite zone de données est constituée des sections .sdata et .sbss. Les objets peuvent être explicitement placés dans la petite zone de données avec l'attribut « section » utilisant l'une de ces sections.

-msdata=sdata

Placer les petites données globales statiques dans la petite zone de données, mais ne pas générer de code spécial pour les référencer.

-msdata=use

Placer les petites données globales statiques dans la petite zone de données, et générer des instructions spéciales pour les référencer.

-G nombre

Placer les objets globaux et les objets statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. La valeur par défaut pour nombre est 8. L'option -msdata doit valoir sdata ou use pour que cette option ait un quelconque effet.

Tous les modules devraient être compilés avec la même valeur pour -G nombre. Compiler avec des valeurs différentes de nombre pourra fonctionner ou bien pas ; si ça ne fonctionne pas, l'éditeur de liens émettra un message d'erreur -- du code incorrect ne sera pas généré.

Options M88K

Ces options -m sont définies pour les architectures Motorola 88k :

-m88000

Générer du code fonctionnant bien à la fois sur le m88100 et le m88110.

-m88100

Générer du code fonctionnant le mieux sur le m88100, mais tournant également sur le m88110.

-m88110

Générer du code fonctionnant le mieux sur le m88100, mais pouvant ne pas tourner sur le m88110.

-mbig-pic

Option obsolète à supprimer lors de la prochaine révision. Utilisez -fPIC.

-midentify-revision

Inclure une directive « ident » dans la sortie de l'assembleur enregistrant le nom du fichier source, les nom et version du compilateur, l'horodate, et les drapeaux de compilation utilisés.

-mno-underscores

Dans la sortie de l'assembleur, émettre des noms de symboles sans ajouter un caractère de soulignement au début de chaque nom. Le comportement par défaut est d'utiliser un caractère de soulignement comme préfixe pour chaque nom.

-mocs-debug-info

-mno-ocs-debug-info

Inclure (ou pas) de l'information de débogage supplémentaire (sur les registres utilisés dans chaque cadre de pile) comme spécifié dans le Standard de Compatibilité Objet 88open, « OCS ». Cette information additionnelle permet le débogage de code dans lequel le pointeur de cadre a été éliminé. Le comportement par défaut pour DG/UX, SVr4 et Delta 88 SVr3.2 est d'inclure cette information ; d'autres configurations 88k omettent cette information par défaut.

-mocs-frame-position

Durant l'émission d'information de débogage COFF sur les variables automatiques et les paramètres conservés dans la pile, utiliser le décalage à partir de l'adresse de cadre canonique, qui est le pointeur de pile (registre 31) à l'entrée de la fonction. Les configurations DG/UX, SVr4, Delta88 SVr3.2 et BCS utilisent -mocs-frame-position ; d'autres configurations 88k utilisent -mno-ocs-frame-position par défaut.

-mno-ocs-frame-position

Durant l'émission d'information de débogage COFF sur les variables automatiques et les paramètres conservés dans la pile, utiliser le décalage à partir du registre de pointeur de cadre (registre 30). Quand cette option a cours, le pointeur de cadre n'est pas éliminé lorsque de l'information de débogage est requise par l'interrupteur -g.

-moptimize-arg-area

Préserver de l'espace en réorganisant le cadre de pile. Cette option génère du code qui ne respecte pas les spécifications 88open, mais qui utilise moins de mémoire.

-mno-optimize-arg-area

Ne pas réorganiser le cadre de pile pour préserver de l'espace. C'est le comportement par défaut. Le code généré se conforme à la spécification, mais utilise moins de mémoire.

-mshort-data-nombre

Générer des références de données plus petites en les rendant relatives à « r0 », ce qui permet de charger une valeur en utilisant une seule instruction (plutôt que les deux habituelles). Vous contrôlez quelles références de données sont affectées en spécifiant nombre avec cette option. Par exemple, si vous spécifiez -mshort-data-512, alors les références de données affectées sont celles impliquant des déplacements de moins de 512 octets. -mshort-data-num n'a pas d'effet pour un nombre plus grand que 64 Ko.

-mserialize-volatile

-mno-serialize-volatile

Générer (ou pas) du code pour garantir la cohérence séquentielle des références mémoire volatiles. Par défaut, la cohérence est garantie.

L'ordre des références mémoire créées par le processeur MC88110 ne correspond pas toujours à l'ordre des instructions requérant ces références. En particulier, une instruction de chargement (load) peut s'exécuter avant une instruction de stockage (store) la précédant. Un tel réordonnancement viole la cohérence séquentielle des références mémoire volatiles quand il y a de multiples processeur. Quand la cohérence doit être garantie, GCC génère des instructions spéciales, si nécessaire, pour forcer l'exécution dans le bon ordre.

Le processeur MC88100 ne réordonne pas les références mémoire et fournit de ce fait toujours la cohérence séquentielle. Néanmoins, par défaut, GCC génère les instructions spéciales pour garantir la cohérence même quand vous utilisez le -m88100, afin que le code puisse tourner sur un processeur MC88110. Si vous prévoyez ne faire tourner votre code que sur le processeur MC88100, vous pouvez utiliser -mno-serialize-volatile.

Le code supplémentaire généré pour garantir la cohérence peut affecter la performance de votre application. Si vous savez que vous pouvez outrepasser sans dommage cette garantie, vous pouvez utiliser -mno-serialize-volatile.

-msvr4

-msvr3

Activer (-msvr4) ou désactiver (-msvr3) les extensions du compilateur relatives à System V release 4 (SVr4). Cela contrôle les points suivants :

-mversion-03.00

Cette option est obsolète, et est ignorée.

-mno-check-zero-division

-mcheck-zero-division

Générer (ou pas) du code pour garantir que la division entière par zéro est détectée. Par défaut, la détection est garantie.

Certains modèles du processeur MC88100 ne parviennent pas à détecter la division entière par zéro dans certaines conditions. Par défaut, lors de la compilation de code pouvant tourner sur un tel processeur, GCC génère du code qui traque explicitement les diviseurs nuls, et provoque une interruption avec le numéro d'exception 503 quand l'un d'entre eux est détecté. L'utilisation de mno-check-zero-division supprime une telle vérification pour du code généré sur un processeur MC88100.

GCC suppose que le processeur MC88110 détecte correctement toutes les instances de la division entière par zéro. Quand -m88110 est spécifié, aucun contrôle explicite de diviseurs nuls n'est généré, et -mcheck-zero-division ainsi que -mno-check-zero-division sont ignorés.

-muse-div-instruction

Utiliser l'instruction div pour la division entière signée sur le processeur MC88100. Par défaut, l'instruction div n'est pas utilisée.

Sur le processeur MC88100, l'instruction de division entière signée (div) est interrompue par le système d'exploitation en cas d'opérande négatif. Le système d'exploitation effectue l'opération de façon transparente, mais a un coût élevé en terme de temps d'exécution. Par défaut, lors de la compilation de code pouvant tourner sur un processeur MC88100, GCC émule la division entière signée en utilisant l'instruction de division entière non signée (divu), évitant de ce fait la grande pénalité due à la gestion d'une interruption par le système d'exploitation. Une telle émulation possède ses propres coûts, moins importants, en terme de temps et d'espace. Dans la mesure où les opérations de division entière signée importantes de votre code sont effectuées sur deux opérandes non négatifs, il peut être souhaitable d'utiliser l'instruction div directement.

Sur le processeur MC88110, l'instruction div (également connue sous le nom d'instruction divs) traite les opérandes négatifs sans être interrompue par le système d'exploitation. Quand -m88110 est spécifié, -muse-div-instruction est ignoré, et l'instruction div est utilisée pour la division entière signée.

Notez que le résultat de la division de « INT_MIN » par -1 n'est pas défini. En particulier, le comportement d'une telle division peut différer en fonction de l'utilisation éventuelle de -muse-div-instruction.

-mtrap-large-shift

-mhandle-large-shift

Inclure du code pour détecter les décalages de bits de plus de 31 bits ; respectivement, capturer de tels décalages ou émettre du code pour les traiter correctement. Par défaut, GCC ne prend aucune mesure spéciale pour les grands décalages de bits.

-mwarn-passed-structs

Avertir quand une fonction passe une « struct » comme argument ou comme résultat. Les conventions de passage de structures ont changé durant l'évolution du langage C, et sont souvent la source de problèmes de portabilité. Par défaut, GCC n'émet pas de tels avertissements.

Options IBM RS/6000 et PowerPC

Ces options -m sont définies pour les IBM RS/6000 et les PowerPC:

-mpower

-mno-power

-mpower2

-mno-power2

-mpowerpc

-mno-powerpc

-mpowerpc-gpopt

-mno-powerpc-gpopt

-mpowerpc-gfxopt

-mno-powerpc-gfxopt

-mpowerpc64

-mno-powerpc64

GCC supporte deux infrastructures de jeux d'instructions proches pour le RS/6000 et le PowerPC. Le jeu d'instructions POWER est composé des instructions supportées par la puce rios utilisée dans les systèmes RS/6000 originaux, et le jeu d'instructions PowerPC constitue l'architecture des microprocesseurs Motorola MPC5xx, MPC6xx, MPC8xx, et des microprocesseurs IBM 4xx.

Aucune architecture n'est un sous-ensemble d'une autre. Néanmoins, il y a un grand sous-ensemble commun d'instructions supportée par les deux. Un registre MQ est inclus dans les processeurs supportant l'architecture POWER.

Vous pouvez utiliser ces options pour spécifier quelles instructions sont disponibles sur le processeur que vous utilisez. La valeur par défaut pour ces options est déterminée lorsque vous configurez GCC. Spécifier -mcpu=type-cpu surcharge la spécification de ces options. Nous recommandons l'utilisation de l'option -mcpu=type-cpu plutôt que les options listées ci-dessus.

L'option -mpower permet à GCC de générer des instructions qui ne se retrouvent que dans l'architecture POWER, et d'utiliser le registre MQ. Spécifier -mpower2 implique -power, et permet également à GCC de générer des instructions qui sont présentes dans l'architecture POWER2, mais pas dans l'architecture POWER originale.

L'option -mpowerpc permet à GCC de générer des instructions qui ne se trouvent que dans le sous-ensemble 32 bits de l'architecture PowerPC. Spécifier -mpowerpc-gpopt implique -mpowerpc et permet également à GCC d'utiliser les instructions optionnelles d'architecture PowerPC du groupe General Purpose (à usage général), ce qui inclut la racine carrée flottante. Spécifier -mpowerpc-gfxopt implique -mpowerpc et permet également à GCC d'utiliser les instructions optionnelles d'architecture PowerPC du groupe Graphics, ce qui inclut le « select » flottant.

L'option -mpowerpc64 permet à GCC de générer les instructions 64 bits additionnelles qui se trouvent dans l'architecture PowerPC64, et de traiter les GPRs en tant que quantités 64 bits (double mots). GCC utilise -mno-powerpc64 par défaut.

Si vous spécifiez -mno-power et -mno-powerpc, GCC n'utilisera que les instructions provenant du sous-ensemble commun aux deux architectures, plus certains appels spéciaux AIX en mode commun, et n'utilisera pas le registre MQ. Spécifier -mpower et -mpowerpc permet à GCC d'utiliser n'importe quelle instruction de l'une quelconque des architectures, et d'utiliser le registre MQ ; spécifiez ceci pour le Motorola MPC601.

-mnew-mnemonics

-mold-mnemonics

Sélectionner quels mnémoniques utiliser dans le code assembleur généré. Avec -mnew-mnemonics, GCC utilise les mnémoniques assembleur définis pour l'architecture PowerPC. Avec -mold-mnemonics, il utilise les mnémoniques assembleur définis pour l'architecture POWER. Les instructions définies pour une seule architecture n'ont qu'un seul mnémonique ; GCC utilise ce mnémonique quelle que soit l'option spécifiée.

GCC utilise par défaut les mnémoniques appropriés à l'architecture utilisée. Spécifier -mcpu=type-cpu surcharge parfois la valeur de cette option. À moins que vous ne construisiez un compilateur croisé, vous ne devriez spécifier ni -mnew-mnemonics, ni -mold-mnemonics, mais devriez à la place accepter le comportement par défaut

-mcpu=type-cpu

Fixer le type d'architecture, l'utilisation des registres, le choix des mnémoniques, et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont rios, rios1, rsc, rios2, rs64a, 601, 602, 603, 603e, 604, 604e, 620, 630, 740, 7400, 7450, 750, power, power2, powerpc, 403, 505, 801, 821, 823, 860 et common.

-mcpu=common sélectionne un processeur complètement générique. Du code généré avec cette option tournera sur tout processeur POWER ou PowerPC. GCC n'utilisera que les instructions du sous-ensemble commun aux deux architectures, et n'utilisera pas le registre MQ. GCC suppose un modèle de processeur générique approprié à des fins d'ordonnancement.

-mcpu=power, -mcpu=power2, -mcpu=powerpc, et -mcpu=powerpc64 spécifient des types de machine d'architecture POWER, POWER2, PowerPC 32 bits pur (c.-à-d. pas MPC601), et PowerPC 64 bits, avec un modèle de processeur générique approprié à des fins d'ordonnancement.

Les autres options spécifient un processeur spécifique. Du code généré avec ces options tournera le mieux sur ce processeur, et peut ne pas tourner du tout sur d'autres.

Les options -mcpu activent ou désactivent automatiquement d'autres options -m de la façon suivante :

-mtune=type-cpu

Fixer les paramètres d'ordonnancement des instructions pour le type de machine type-cpu, mais ne pas fixer le type d'architecture, l'utilisation des registres ou le choix des mnémoniques comme le ferait -mcpu=type-cpu. Les valeurs de type-cpu utilisées par -mtune sont les mêmes que celles de -mcpu. Si ces deux options sont spécifiées de concert, le code généré utilisera l'architecture, les registres et les mnémoniques définis par -mcpu, mais les paramètres d'ordonnancement fixés par -mtune.

-maltivec

-mno-altivec

Ces interrupteurs activent ou désactivent l'utilisation des fonctions intégrées qui donnent accès au jeu d'instructions AltiVec. Vous pourriez également devoir utiliser -mabi=altivec pour ajuster l'ABI courante avec les améliorations AltiVec.

-mfull-toc

-mno-fp-in-toc

-mno-sum-in-toc

-mminimal-toc

Modifier la génération de la TOC (Table Of Contents, table des matières), qui est créée pour chaque fichier exécutable. L'option -mfull-toc est sélectionnée par défaut. Dans ce cas, GCC allouera au moins une entrée dans la TOC pour chaque référence de variable non automatique dans votre programme. GCC placera également des constantes flottantes dans la TOC. Néanmoins, seules 16384 entrées sont disponibles dans la TOC.

Si vous recevez un message d'erreur de la part de l'éditeur de liens disant que vous avez dépassé l'espace disponible dans la TOC, vous pouvez réduire l'espace de TOC utilisé avec les options -mno-fp-in-toc et -mno-sum-in-toc. -mno-fp-in-toc empêche GCC de placer des constantes flottantes dans la TOC et -mno-sum-in-toc force GCC à générer du code pour calculer la somme d'une adresse et d'une constante au moment de l'exécution au lieu de placer cette somme dans la TOC. Vous pouvez spécifier l'une de ces options ou les deux en même temps. Chacune oblige GCC à produire un code très légèrement plus lent et gros afin d'épargner de l'espace dans la TOC.

Si vous êtes toujours à court d'espace dans la TOC même quand vous spécifiez ces deux options, spécifiez -mminimal-toc à la place. Cette option force GCC à ne créer qu'une entrée dans la TOC pour chaque fichier. Quand vous spécifiez cette option, GCC produira du code qui sera plus lent et plus gros mais qui utilisera extrêmement peu d'espace dans la TOC. Vous pourriez n'utiliser cette option que pour des fichiers contenant du code moins fréquemment exécuté.

-maix64

-maix32

Activer l'ABI et la convention d'appel AIX 64 bits : les pointeurs 64 bits, le type « long » 64 bits, et l'infrastructure nécessaire pour les supporter. Spécifier -maix64 implique -mpowerpc64 et -mpowerpc, alors que -maix32 désactive l'ABI 64 bits et implique -mno-powerpc64. GCC utilise -maix32 par défaut.

-mxl-call

-mno-xl-call

Sur AIX, passer les arguments flottants à des fonctions prototypées au-delà de la zone de sauvegarde des registres (Register Save Area, RSA) sur la pile en plus des arguments FPRs (frame pointer, cadre de pile). La convention d'appel AIX a été étendue mais n'a pas été initialement documentée pour traiter un cas obscur du C K&R d'un appel de fonction qui prend l'adresse de ses arguments avec moins d'arguments que déclaré. Les compilateurs AIX XL accèdent aux arguments flottants qui ne tiennent pas dans la RSA de la pile quand une sous-routine est compilée sans optimisation. Puisque toujours stocker les arguments flottants sur la pile est inefficace et rarement nécessaire, cette option n'est pas activée par défaut et n'est nécessaire que lors d'appel de sous-routines compilées par les compilateurs AIX XL sans optimisation.

-mpe

Supporter l'IBM RS/6000 SP Parallel Environment (PE, environnement parallèle). Lier une application écrite pour utiliser le passage de messages avec un code de démarrage spécial pour permettre à l'application de pouvoir s'exécuter. Le système doit disposer du PE installé à l'endroit standard (/usr/lpp/ppe.poe/), ou le fichier de specs doit être surchargé avec l'option -specs= pour spécifier la localisation du répertoire approprié. L'Environnement Parallèle ne supporte pas les threads, de sorte que les options -mpe et -pthread sont incompatibles.

-msoft-float

-mhard-float

Générer du code qui n'utilise pas (qui utilise) le groupe de registres flottants. Une émulation logicielle des flottants est fournie si vous utilisez l'option -msoft-float, et passez l'option à GCC lors de l'édition des liens.

-mmultiple

-mno-multiple

Générer du code qui utilise (qui n'utilise pas) les instructions de chargement de plusieurs mots (load multiple word) et les instructions de stockage de plusieurs mots (store multiple word). Ces instructions sont générées par défaut sur les systèmes POWER, et ne sont pas générées sur les systèmes PowerPC. N'utilisez pas -mmultiple sur des systèmes PowerPC petit-boutistes, car ces instructions ne fonctionnent pas quand le processeur fonctionne en mode petit-boutiste. Les exceptions sont PPC740 et PPC750 qui permettent l'utilisation des instructions en mode petit-boutiste.

-mstring

-mno-string

Générer du code qui utilise (qui n'utilise pas) les instructions de chargement de chaînes de caractères (load string), et les instructions de stockage de mot de chaîne (store string word) afin d'épargner de multiples registres et d'effectuer de petits déplacements de blocs. Ces instructions sont générées par défaut sur les systèmes POWER, et ne sont pas générées sur les systèmes PowerPC. N'utilisez pas -mstring sur des systèmes PowerPC petit-boutistes, car ces instructions ne fonctionnent pas quand le processeur fonctionne en mode petit-boutiste. Les exceptions sont PPC740 et PPC750 qui permettent l'utilisation des instructions en mode petit-boutiste.

-mupdate

-mno-update

Générer du code qui utilise (qui n'utilise pas) les instructions de chargement ou de stockage qui mettent à jour le registre de base en lui donnant pour valeur l'adresse de l'emplacement mémoire calculé. Ces instructions sont générées par défaut. Si vous utilisez -mno-update, il y a un petit délai entre le moment où le pointeur de pile est mis à jour, et celui où l'adresse du cadre précédent est stockée, ce qui signifie que le code qui traverse le cadre de pile lors d'interruptions ou de signaux peut voir ses données corrompues.

-mfused-madd

-mno-fused-madd

Générer du code qui utilise (qui n'utilise pas) les instructions flottantes de multiplication (multiply) et d'accumulation (accumulate). Ces instructions sont générées par défaut si des flottants « matériels » sont utilisés.

-mno-bit-align

-mbit-align

Sur System V.4 et les systèmes PowerPC embarqués, forcer (ne pas forcer) les structures et les unions contenant des champs-bit à être alignées au type de base du champ-bit.

Par exemple, une structure ne contenant rien à part 8 champs-bit « unsigned » de longueur 1 serait alignée à une limite de 4 octets et aurait une taille de 4 octets. En utilisant -mno-bit-align, la structure serait alignée à une limite de 1 octet et aurait une taille de 1 octet.

-mno-strict-align

-mstrict-align

Sur System V.4 et les systèmes PowerPC embarqués, ne pas supposer (supposer) que les références mémoire non alignées peuvent être traitées par le système.

-mrelocatable

-mno-relocatable

Sur les systèmes PowerPC embarqués, générer du code qui permet (ne permet pas) au programme d'être relogé à une adresse différente au moment de l'exécution. Si vous utilisez -mrelocatable sur un module, tous les objets liés avec lui doivent être compilés avec -mrelocatable ou -mrelocatable-lib.

-mrelocatable-lib

-mno-relocatable-lib

Sur les systèmes PowerPC embarqués, générer du code qui permet (ne permet pas) au programme d'être relogé à une adresse différente au moment de l'exécution. Les modules compilés avec -mrelocatable-lib peuvent être liés aussi bien avec des modules compilés sans -mrelocatable et -mrelocatable-lib, qu'avec des modules compilés avec les options -mrelocatable.

-mno-toc

-mtoc

Sur System V.4 et les systèmes PowerPC embarqués, ne pas supposer (supposer) que le registre 2 contient un pointeur vers une zone globale pointant vers les adresses utilisées dans le programme.

-mlittle

-mlittle-endian

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le processeur en mode petit-boutiste. L'option -mlittle-endian est identique à -mlittle.

-mbig

-mbig-endian

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le processeur en mode gros-boutiste. L'option -mbig-endian est identique à -mbig.

-mcall-sysv

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code utilisant des conventions d'appel qui adhèrent au document de travail de mars 1995 de l'Application Binary Interface System V, complément pour le processeur PowerPC. C'est le comportement par défaut à moins que vous n'ayez configuré GCC en utilisant powerpc-*-eabiaix.

-mcall-sysv-eabi

Spécifier les options -mcall-sysv et -meabi.

-mcall-sysv-noeabi

Spécifier les options -mcall-sysv et -mno-eabi.

-mcall-aix

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code utilisant des conventions d'appel qui sont similaires à celles utilisées sur AIX. C'est le comportement par défaut à moins que vous n'ayez configuré GCC en utilisant powerpc-*-eabiaix.

-mcall-solaris

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le système d'exploitation Solaris.

-mcall-linux

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour les systèmes GNU basés sur Linux.

-mcall-gnu

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour les systèmes GNU basés sur Hurd.

-mcall-netbsd

Sur System V.4 et les systèmes PowerPC embarqués, compiler du code pour le système d'exploitation NetBSD.

-maix-struct-return

Retourner toutes les structures en mémoire (comme spécifié par l'ABI AIX).

-msvr4-struct-return

Retourner les structures de moins de 8 octets dans des registres (comme spécifié par l'ABI SVR4).

-mabi=altivec

Étendre l'ABI courante avec les extensions AltiVec de l'ABI. Cela ne modifie pas l'ABI par défaut ; au lieu de cela, les extensions AltiVec de l'ABI sont ajoutées à l'ABI courante.

-mabi=no-altivec

Désactiver les extensions AltiVec de l'ABI pour l'ABI courante.

-mprototype

-mno-prototype

Sur System V.4 et les systèmes PowerPC embarqués, supposer que tous les appels à des fonctions prenant un nombre variable d'arguments sont correctement prototypées. Sinon, le compilateur doit insérer une instruction avant chaque appel non prototypé pour allumer ou éteindre le bit 6 du registre de code de condition (CR) afin d'indiquer si des valeurs flottantes ont été passées dans les registres flottants au cas où la fonction prendrait un nombre variable d'arguments. Avec -mprototype, seuls les appels à des fonctions prototypées à nombre variable d'arguments allumeront ou éteindront le bit.

-msim

Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé sim-crt0.o, et que les bibliothèques C standard sont libsim.a et libc.a. Utilisé par défaut pour les configurations powerpc-*-eabisim.

-mmvme

Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libmvme.a et libc.a.

-mads

Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libads.a et libc.a.

-myellowknife

Sur les systèmes PowerPC embarqués, supposer que le module de démarrage est appelé crt0.o, et que les bibliothèques C standard sont libyk.a et libc.a.

-mvxworks

Sur System V.4 et les systèmes PowerPC embarqués, spécifier que vous compilez pour un système VxWorks.

-memb

Sur les systèmes PowerPC embarqués, allumer le bit PPC_EMB dans l'en-tête de drapeaux ELF pour indiquer que des relogements étendus eabi sont utilisés.

-meabi

-mno-eabi

Sur System V.4 et les systèmes PowerPC embarqués, adhérer (ou pas) à la Embedded Applications Binary Interface (eabi) qui constitue un ensemble de modifications aux spécifications System V.4. Sélectionner -meabi signifie que la pile est alignée à une limite de 8 octets, une fonction « __eabi » est appelée à partir de « main » pour établir l'environnement eabi, et l'option -msdata peut utiliser à la fois « r2 » et « r13 » pour pointer sur deux petites zones de données séparées. Sélectionner -mno-eabi signifie que la pile est alignée à une limite de 16 octets, ne pas appeler une fonction d'initialisation à partir de « main », et l'option -msdata n'utilisera que « r13 » pour pointer sur une unique petite zone de données. L'option -meabi est activée par défaut si vous avez configuré GCC en utilisant l'une des options powerpc*-*-eabi*.

-msdata=eabi

Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques « const » initialisées dans la section .sdata2, vers laquelle pointe le registre « r2 ». Placer les petites données globales statiques non-« const » initialisées dans la section .sdata, vers laquelle pointe le registre « r13 ». Placer les petites données globales statiques non initialisées dans la section .sbss, qui est adjacente à la section .sdata. L'option -msdata=eabi est incompatible avec l'option -mrelocatable. L'option -msdata=eabi active également l'option -memb.

-msdata=sysv

Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques dans la section .sdata, vers laquelle pointe le registre « r13 ». Placer les petites données globales statiques non initialisées dans la section .sbss, qui est adjacente à la section .sdata. L'option -msdata=sysv est incompatible avec l'option -mrelocatable.

-msdata=default

-msdata

Sur System V.4 et les systèmes PowerPC embarqués, si -meabi est utilisé, compiler du code comme pour -msdata=eabi, sinon compiler du code comme pour -msdata=sysv.

-msdata-data

Sur System V.4 et les systèmes PowerPC embarqués, placer les petites données globales statiques dans la section .sdata. Placer les petites données globales statiques non initialisées dans la section .sbss. Néanmoins, ne pas utiliser le registre « r13 » pour adresser les petites données. C'est le comportement par défaut à moins que d'autres options -msdata ne soient utilisées.

-msdata=none

-mno-sdata

Sur les systèmes PowerPC embarqués, placer toutes les données globales statiques initialisées dans la section .data, et toutes les données non initialisées dans la section .bss.

-G nombre

Sur les systèmes PowerPC embarqués, placer les éléments globaux et statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. Par défaut, nombre est 8. L'interrupteur -G nombre est également passé à l'éditeur de liens. Tous les modules devraient être compilés avec la même valeur pour -G nombre.

-mregnames

-mno-regnames

Sur System V.4 et les systèmes PowerPC embarqués, émettre (ou pas) des noms de registres dans la sortie en langage assembleur en utilisant des formes symboliques.

-pthread

Ajouter le support pour le multithreading en utilisant la bibliothèque pthreads. Cette option définit des drapeaux pour le préprocesseur et l'éditeur des liens.

Options IBM RT

Ces options -m sont définies pour le PC IBM RT :

-min-line-mul

Utiliser une séquence de code en ligne pour les multiplications d'entiers. C'est le comportement par défaut.

-mcall-lib-mul

Appeler « lmul$$ » pour la multiplication d'entiers.

-mfull-fp-blocks

Générer des blocs de données flottantes de taille complète, incluant le montant minimal d'espace de scratch (gribouillage) recommandé par IBM. C'est le comportement par défaut.

-mminimum-fp-blocks

Ne pas inclure d'espace de scratch supplémentaire dans les blocs de données flottantes. Cela résulte en un code plus court, mais en une exécution plus lente, puisque l'espace de scratch doit être alloué dynamiquement.

-mfp-arg-in-fpregs

Utiliser une séquence d'appel incompatible avec la convention d'appel d'IBM dans lequel les arguments flottants sont passés dans des registres flottants. Notez que « varargs.h » et « stdarg.h » ne fonctionneront pas avec des opérandes flottants si cette option est spécifiée.

-mfp-arg-in-gregs

Utiliser la convention d'appel normale pour les arguments flottants. C'est le comportement par défaut.

-mhc-struct-return

Retourner les structures de plus d'un mot en mémoire, plutôt que dans un registre. Ceci fournit la compatibilité avec le compilateur MetaWare HighC (hc). Utilisez l'option -fpcc-struct-return pour la compatibilité avec le compilateur Portable C Compiler (pcc).

-mnohc-struct-return

Retourner certaines structures de plus d'un mot dans des registres, quand c'est opportun. C'est le comportement par défaut. Pour la compatibilité avec les compilateurs fournis par IBM, utilisez ou bien -fpcc-struct-return ou bien -mhc-struct-return.

Options MIPS

Ces options -m sont définies pour la famille d'ordinateurs MIPS :

-march=type-cpu

Supposer les valeurs par défaut pour le type de machine type-cpu lors de la génération d'instructions. Les choix pour type-cpu sont r2000, r3000, r3900, r4000, r4100, r4300, r4400, r4600, r4650, r5000, r6000, r8000 et orion. De plus, les r2000, r3000, r4000, r5000 et r6000 peuvent être abrégés en r2k (ou r2K), r3k, etc.

-mtune=type-cpu

Supposer les valeurs par défaut pour le type de machine type-cpu lors de l'ordonnancement des instructions. Les choix pour type-cpu sont r2000, r3000, r3900, r4000, r4100, r4300, r4400, r4600, r4650, r5000, r6000, r8000 et orion. De plus, r2000, r3000, r4000, r5000 et r6000 peuvent être abrégées en r2k (ou r2K), r3k, etc. Bien qu'utiliser un type-cpu spécifique règle les choses de façon appropriée pour cette puce particulière, le compilateur ne générera pas de code qui ne répond pas au niveau 1 de l'ISA MIPS (Instruction Set Architecture, architecture de jeu d'instructions) si aucun interrupteur -mipsX ou -mabi n'est utilisé.

-mcpu=type-cpu

Revient à spécifier -march et -mtune de concert.

-mips1

Émettre des instructions pour le niveau 1 de l'ISA MIPS. C'est le comportement par défaut. r3000 est le type-cpu par défaut à ce niveau ISA.

-mips2

Émettre des instructions pour le niveau 2 de l'ISA MIPS (instructions de branchement probable, racine carrée). r6000 est le type-cpu par défaut à ce niveau ISA.

-mips3

Émettre des instructions pour le niveau 3 de l'ISA MIPS (instructions 64 bits). r4000 est le type-cpu par défaut à ce niveau ISA.

-mips4

Émettre des instructions pour le niveau 4 de l'ISA MIPS (instructions de déplacement conditionnel, prérecherche, de FPU améliorée). r8000 est le type-cpu par défaut à ce niveau ISA.

-mfp32

Supposer que 32 registres flottants 32 bits sont disponibles. C'est le comportement par défaut.

-mfp64

Supposer que 32 registres flottants 64 bits sont disponibles. C'est le comportement par défaut quand l'option -mips3 est utilisée.

-mfused-madd

-mno-fused-madd

Générer du code qui utilise (n'utilise pas) les instructions de multiplication (multiply) et d'accumulation (accumulate) flottantes, quand elles sont disponibles. Ces instructions sont générées par défaut si elles sont disponibles, mais cela peut être indésirable si la précision supplémentaire cause certains problèmes, ou sur certaines puces dans le mode où les nombres dénormalisés sont arrondis vers zéro lorsque ces nombres dénormalisés générés par des instructions de multiplication et d'accumulation flottantes déclenchent des exceptions.

-mgp32

Supposer que 32 registres 32 bits à usage général sont disponibles. C'est le comportement par défaut.

-mgp64

Supposer que 32 registres 64 bits à usage général sont disponibles. C'est le comportement par défaut quand l'option -mips3 est utilisée.

-mint64

Forcer les types int et long à avoir 64 bits de large. Voyez -mlong32 pour en savoir plus sur la largeur par défaut, et sur la largeur des pointeurs.

-mlong64

Forcer les types long à avoir 64 bits de large. Voyez -mlong32 pour en savoir plus sur la largeur par défaut, et sur la largeur des pointeurs.

-mlong32

Forcer les types long, int et pointeurs à avoir 32 bits de large.

Si aucune des options -mlong32, -mlong64 ou -mint64 n'est utilisée, la taille des ints, longs et pointeurs dépend de l'ABI et de l'ISA choisies. Pour -mabi=32 et -mabi=n32, les ints et longs font 32 bits de large. Pour -mabi=64, les ints font 32 bits, et les longs font 64 bits de large. Pour -mabi=eabi et -mips1 ou -mips2, les ints et les longs font 32 bits de large. Pour -mabi=eabi et des ISAs plus élevées, les ints font 32 bits, et les longs font 64 bits de large. La largeur des types pointeurs est le minimum de la largeur des longs et de la largeur des registres à usage général (qui dépend à son tour de l'ISA).

-mabi=32

-mabi=o64

-mabi=n32

-mabi=64

-mabi=eabi

Générer du code pour l'ABI indiquée. Le niveau d'instructions par défaut est -mips1 pour 32, -mips3 pour n32 et -mips4 sinon. Inversement, avec -mips1 ou -mips2, l'ABI par défaut est 32 ; sinon, l'ABI par défaut est 64.

-mmips-as

Générer du code pour l'assembleur MIPS, et invoquer mips-tfile pour ajouter des informations de débogage normales. C'est le comportement par défaut pour toutes les plate-formes sauf pour la plate-forme de référence OSF/1, utilisant le format objet OSF/rose. Si l'un des deux interrupteurs -gstabs ou -gstabs+ est utilisé, le programme mips-tfile encapsulera le stabs à l'intérieur d'ECOFF MIPS.

-mgas

Générer du code pour l'assembleur GNU. C'est le comportement par défaut pour la plate-forme de référence OSF/1, utilisant le format objet OSF/rose. C'est également utilisé par défaut si l'option de configuration --with-gnu-as est employée.

-msplit-addresses

-mno-split-addresses

Générer du code pour charger les parties haute et basse des constantes adresses séparément. Cela permet à GCC d'optimiser les chargements redondants des bits de poids forts des adresses. Cette optimisation requiert GNU as et GNU ld. Cette optimisation est activée par défaut pour certaines cibles embarquées où GNU as et GNU ld sont standard.

-mrnames

-mno-rnames

L'interrupteur -mrnames indique de produire du code utilisant les noms logiciels MIPS pour les registres, au lieu des noms matériels (p.ex. a0 au lieu de $4). Le seul assembleur connu qui supporte cette option est l'assembleur Algorithmics.

-mgpopt

-mno-gpopt

L'interrupteur -mgpopt indique d'écrire toutes les déclarations de données avant les instructions dans la section de texte ; ceci permet à l'assembleur MIPS de générer des références mémoire d'un mot au lieu d'utiliser deux mots pour les éléments de données globaux courts ou statiques. C'est activé par défaut si l'optimisation est sélectionnée.

-mstats

-mno-stats

Pour chaque fonction non en ligne traitée, l'interrupteur -mstats oblige le compilateur à émettre une ligne dans le fichier standard d'erreurs pour afficher des statistiques sur le programme (nombre de registres sauvegardés, taille de la pile, etc.).

-mmemcpy

-mno-memcpy

L'interrupteur -mmemcpy fait appeler à tous les déplacements de blocs la fonction de chaînes de caractères appropriée (memcpy ou bcopy) au lieu d'éventuellement générer du code en ligne.

-mmips-tfile

-mno-mips-tfile

L'interrupteur -mno-mips-tfile interdit au compilateur de post-traiter le fichier objet avec le programme mips-tfile après que l'assembleur MIPS l'ait généré pour ajouter un support au débogage. Si mips-tfile n'est pas lancé, alors aucune variable locale ne sera accessible au débogueur. De plus, les objets stage2 et stage3 verront les noms des fichiers temporaires passés à l'assembleur en étant embarqués dans le fichier objet, ce qui signifie que les objets ne seront pas comparés comme étant égaux. L'interrupteur -mno-mips-tfile ne devrait être utilisé que lorsqu'il y a des bogues dans le programme mips-tfile qui empêchent la compilation.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

-mhard-float

Générer une sortie contenant des instructions flottantes. C'est le comportement par défaut si vous utilisez les sources non modifiées.

-mabicalls

-mno-abicalls

Émettre (ou ne pas émettre) les pseudo-opérations .abicalls, .cpload et .cprestore que certains portages System V.4 utilisent pour du code indépendant de la position.

-mlong-calls

-mno-long-calls

Effectuer tous les appels avec l'instruction JALR, qui requiert le chargement d'une adresse de fonction dans un registre avant l'appel. Vous devez utiliser cet interrupteur si vous appelez des fonctions situées hors du segment de 512 Mo actuel sans utiliser de pointeurs de fonction pour ce faire.

-mhalf-pic

-mno-half-pic

Placer les pointeurs vers des références externes dans la section de données, et les charger, plutôt que de placer les références dans la section de texte.

-membedded-pic

-mno-embedded-pic

Générer du code PIC convenant à certains systèmes embarqués. Tous les appels sont effectués en utilisant l'adresse relative au PC, et toutes les données sont adressées en utilisant le registre $gp. Pas plus de 65536 octets de données globales peuvent être utilisés. Ceci requiert GNU as et GNU ld qui font la plus grosse partie du travail. Cela fonctionne actuellement sur les cibles qui utilisent ECOFF ; cela ne fonctionne pas avec ELF.

-membedded-data

-mno-embedded-data

Allouer des variables dans la section de données accessibles en lecture uniquement en premier lieu si c'est possible, sinon dans la petite section de données si c'est possible, sinon dans les données. Cela donne du code légèrement plus lent que le code par défaut, mais réduit la taille en RAM requise lors de l'exécution, ce qui peut donc être préféré pour certains systèmes embarqués.

-muninit-const-in-rodata

-mno-uninit-const-in-rodata

Quand il est utilisé de concert avec -membedded-data, il stockera toujours les variables const non initialisées dans la section de données accessibles en lecture uniquement.

-msingle-float

-mdouble-float

L'interrupteur -msingle-float indique à gcc de supposer que le coprocesseur flottant ne supporte que les opérations en simple précision, comme sur la puce r4650. L'interrupteur -mdouble-float permet à gcc d'utiliser les opérations en double précision. C'est le comportement par défaut.

-mmad

-mno-mad

Autoriser l'utilisation des instructions mad, madu et mul, comme sur la puce r4650.

-m4650

Activer -msingle-float, -mmad et, du moins à l'heure actuelle, -mcpu=r4650.

-mips16

-mno-mips16

Permettre les instructions 16 bits.

-mentry

Utiliser les pseudo-opérations entry et exit. Cette option ne peut être utilisée qu'avec -mips16.

-EL

Compiler du code pour le processeur en mode petit-boutiste. Les bibliothèques requises sont censées exister.

-EB

Compiler du code pour le processeur en mode gros-boutiste. Les bibliothèques requises sont censées exister.

-G nombre

Placer les éléments globaux et statiques d'au plus nombre octets dans les petites sections de données ou bss au lieu de la section de données ou bss normale. Ceci permet à l'assembleur d'émettre des instructions de référence mémoire d'un mot basées sur le pointeur global (gp ou $28), au lieu des deux mots habituels. Par défaut, nombre vaut 8 quand l'assembleur MIPS est utilisé, et 0 quand l'assembleur GNU est utilisé. L'interrupteur -G nombre est également transmis à l'assembleur et à l'éditeur de liens. Tous les modules devraient être compilés avec la même valeur pour -G nombre.

-nocpp

Indiquer à l'assembleur MIPS de ne pas exécuter son préprocesseur sur les fichiers assembleur utilisateurs (possédant le suffixe .s) lors de leur assemblage.

-mfix7000

Passer une option à gas qui provoquera l'insertion de nops (instructions factices) si la lecture du registre destination d'une instruction mfhi ou mflo se produit dans les deux instructions suivantes.

-no-crt0

Ne pas inclure le crt0 par défaut.

-mflush-func=fonc

-mno-flush-func

Spécifie la fonction à appeler pour vider les caches I et D, ou ne pas appeler de telles fonctions. Si elle est appelée, la fonction doit prendre les mêmes arguments que la fonction « _flush_func() » habituelle, c.-à-d. l'adresse de l'intervalle mémoire pour lequel le cache est en cours de vidage, la taille de l'intervalle mémoire, et le nombre 3 (pour vider les deux caches). La fonction par défaut dépend de la cible pour laquelle gcc a été configuré, mais est habituellement soit _flush_func soit __cpu_flush.

Ces options sont définies par la macro de description de machine « TARGET_SWITCHES ». Les options par défaut sont également définies par cette macro, qui vous permet de les modifier.

Options Intel 386 et AMD x86-64

Ces options -m sont définies pour les familles d'ordinateurs i386 et x86-64 :

-mcpu=type-cpu

Optimaliser pour type-cpu tout ce qui s'applique au code généré, sauf en ce qui concerne l'ABI et le jeu d'instructions disponibles. Les choix possibles pour type-cpu sont i386, i486, i586, i686, pentium, pentium-mmx, pentiumpro, pentium2, pentium3, pentium4, k6, k6-2, k6-3, athlon, athlon-tbird, athlon-4, athlon-xp et athlon-mp.

Bien qu'utiliser un type-cpu spécifique réglera les choses de façon appropriée pour cette puce particulière, le compilateur ne générera pas de code ne tournant pas sur le i386 si l'option -march=type-cpu n'est pas utilisée. i586 est équivalent à pentium et i686 est équivalent à pentiumpro. k6 et athlon sont les puces d'AMD concurrentes de celles d'Intel.

-march=type-cpu

Générer des instructions pour le type de machine type-cpu. Les choix pour type-cpu sont les mêmes que pour -mcpu. De plus, spécifier -march=type-cpu implique -mcpu=type-cpu.

-m386

-m486

-mpentium

-mpentiumpro

Ces options sont des synonymes pour -mcpu=i386, -mcpu=i486, -mcpu=pentium et -mcpu=pentiumpro respectivement. Ces synonymes sont dépréciés.

-mfpmath=unité

Générer des arithmétiques flottantes pour l'unité sélectionnée. Les choix pour unité sont :

-masm=dialecte

Produire des instructions asm utilisant le dialecte sélectionné. Les choix supportés sont intel et att (le dialecte par défaut).

-mieee-fp

-mno-ieee-fp

Contrôler si le compilateur utilise ou pas les comparaisons flottantes IEEE. Celles-ci traitent correctement le cas où le résultat d'une comparaison n'est pas ordonné.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne font pas partie de GCC. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée.

Sur les machines où une fonction retourne des résultats flottants dans la pile de registres 80387, certains codes opératoires flottants peuvent être émis même si -msoft-float est utilisé.

-mno-fp-ret-in-387

Ne pas utiliser les registres de la FPU pour les valeurs de retour des fonctions.

La convention d'appel habituelle retourne les valeurs de retour de fonction des types « float » et « double » dans un registre de la FPU, même s'il n'y a pas de FPU, l'idée sous-jacente étant que le système d'exploitation devrait émuler une FPU.

L'option -mno-fp-ret-in-387 fait renvoyer de telles valeurs dans des registres CPU ordinaires à la place.

-mno-fancy-math-387

Certains émulateurs 387 ne supportent pas les instructions « sin », « cos » et « sqrt » pour le 387. Spécifiez cette option pour éviter de générer ces instructions. C'est utilisé par défaut sous FreeBSD, OpenBSD et NetBSD. Cette option est surchargée quand -march indique que le cpu cible aura toujours une FPU et que l'instruction ne nécessite pas d'émulation. À partir de la révision 2.6.1, ces instructions ne sont pas générées à moins que vous utilisiez également l'interrupteur -funsafe-math-optimizations.

-malign-double

-mno-align-double

Contrôler si GCC aligne les variables « double », « long double » et « long long » à des limites de deux ou de un mots. Aligner les variables « double » à des limites de deux mots produira du code tournant un peu plus rapidement sur un Pentium aux dépens d'une plus grosse consommation mémoire.

Avertissement : si vous utilisez l'interrupteur -malign-double, les structures contenant les types prémentionnés seront alignées différemment de ce qui est édicté dans les spécifications d'interface binaire applicative publiées pour le 386.

-m128bit-long-double

Contrôler la taille du type « long double ». L'interface d'application binaire i386 spécifie que sa taille doit être de 12 octets, alors que les architectures modernes (Pentium et supérieurs) préfèrent que « long double » soit aligné à des limites de 8 ou 16 octets. C'est impossible à atteindre avec des doubles d'une longueur de 12 octets lors des accès à des tableaux.

Avertissement : si vous utilisez l'interrupteur -m128bit-long-double, les structures et les tableaux contenant des « long double » verront leur taille modifiée. De plus, la convention d'appel de fonction pour les fonctions prenant des « long double » sera modifiée.

-m96bit-long-double

Fixer la taille de « long double » à 96 bits comme requis par l'ABI. C'est le comportement par défaut.

-msvr3-shlib

-mno-svr3-shlib

Contrôler si GCC place des variables locales non initialisées dans les segments « bss » ou « data ». -msvr3-shlib les place dans « bss ». Ces options ne sont significatives que sous System V Release 3.

-mrtd

Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant avec l'instruction « ret » nombre, qui dépile ses arguments en sortant. Ceci épargne une instruction à l'appelant qui ne doit alors pas dépiler les arguments.

Vous pouvez spécifier qu'une fonction individuelle est appelée avec cette séquence d'appel avec l'attribut de fonction stdcall. Vous pouvez également surcharger l'option -mrtd en utilisant l'attribut de fonction cdecl.

Avertissement : cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

Vous devez également fournir des prototypes de fonction pour toutes les fonctions prenant un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En plus, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

-mregparm=nombre

Contrôler le nombre de registres qui sont utilisés pour passer des arguments entiers. Par défaut, aucun registre n'est utilisé pour passer des arguments, et au plus 3 registres peuvent être utilisés. Vous pouvez contrôler ce comportement pour une fonction spécifique en utilisant l'attribut de fonction regparm.

Avertissement : si vous utilisez cet interrupteur, et que nombre est non nul, alors vous devez construire tous les modules avec la même valeur, ce qui inclut toutes les bibliothèques, y compris les bibliothèques systèmes et les modules de démarrage.

-mpreferred-stack-boundary=nombre

Essayer de garder la limite de la pile alignée à des limites de 2 exposant nombre octets. Si -mpreferred-stack-boundary n'est pas spécifié, la limite par défaut est 4 (16 octets ou 128 bits), sauf lors d'une optimisation pour la taille du code (-Os), auquel cas l'alignement par défaut est l'alignement correct minimum (4 octets pour les x86, et 8 octets pour les x86-64).

Sur Pentium et PentiumPro, les valeurs « double » et « long double » devraient être alignées à des limites de 8 octets (voyez -malign-double) ou souffriront sinon de pénalités significatives en termes de temps d'exécution. Sur Pentium III, le type de données « __m128 » de la Streaming SIMD Extension (SSE) souffre de pénalités similaires s'il n'est pas aligné à une limite de 16 octets.

Pour s'assurer de l'alignement correct de ces valeurs sur la pile, la limite de la pile doit être alignée comme requis par toutes les valeurs stockées sur la pile. En outre, chaque fonction doit être générée de sorte qu'elle garde la pile alignée. Ainsi, appeler une fonction compilée avec une frontière de pile préférée plus haute à partir d'une fonction compilée avec une frontière de pile préférée plus basse alignera probablement mal la pile. Il est recommandé que les bibliothèques utilisant des rappels (callbacks) emploient toujours le réglage par défaut.

Cet alignement supplémentaire consomme de l'espace supplémentaire sur la pile, et accroît généralement la taille du code. Le code qui est sensible à l'utilisation d'espace de la pile, comme les systèmes embarqués et les noyaux de systèmes d'exploitation, pourrait vouloir réduire l'alignement préféré à -mpreferred-stack-boundary=2.

-mmmx

-mno-mmx

-msse

-mno-sse

-msse2

-mno-sse2

-m3dnow

-mno-3dnow

Ces interrupteurs activent ou désactivent l'utilisation des fonctions intégrées permettant un accès direct aux extensions MMX, SSE et 3Dnow du jeu d'instructions.

-mpush-args

-mno-push-args

Utiliser des opérations PUSH pour stocker les paramètres sortants. Cette méthode est plus courte et habituellement aussi rapide que la méthode utilisant des opérations SUB/MOV et est activée par défaut. Dans certains cas, la désactiver peut améliorer la performance grâce à un ordonnancement amélioré et à des dépendances réduites.

-maccumulate-outgoing-args

Si cette option est activée, la quantité maximale d'espace requis pour les arguments sortants sera calculée dans le prologue de la fonction. C'est plus rapide sur la plupart des CPUs modernes performance grâce à des dépendances réduites, un ordonnancement amélioré et une utilisation de la pile réduite quand la frontière de pile préférée n'est pas égale à 2. L'inconvénient est un accroissement respectable de la taille du code. Cet interrupteur implique -mno-push-args.

-mthreads

Supporter un traitement des exceptions fiable en présence de threads (thread-safe) sur Mingw32. Le code qui se base sur le traitement des exceptions fiable en présence de threads doit compiler et lier tout le code avec l'option -mthreads. Lors de la compilation, -mthreads définit -D_MT ; lors de l'édition des liens, il lie avec une bibliothèque assistante spéciale pour les threads -lmingwthrd qui nettoie les données de traitement des exceptions pour chaque thread.

-mno-align-stringops

Ne pas aligner la destination d'opérations sur des chaînes de caractères en ligne. Cet interrupteur réduit la taille du code et améliore la performance au cas où la destination serait déjà alignée, mais gcc ne le sait pas.

-minline-all-stringops

Par défaut, GCC ne met en ligne les opérations sur des chaînes de caractères que lorsqu'il sait que la destination est alignée à des limites d'au moins 4 octets. Ceci permet plus de mise en ligne, accroît la taille du code, mais peut améliorer la performance du code qui dépend de memcpy, strlen et memset rapides pour les courtes longueurs.

-momit-leaf-frame-pointer

Ne pas conserver le pointeur de cadre dans un registre pour les fonctions feuilles. Ceci évite les instructions pour sauver, établir et restaurer les pointeurs de cadre, et libère un registre supplémentaire qui sera disponible dans les fonctions feuilles. L'option -fomit-frame-pointer supprime le pointeur de cadre pour toutes les fonctions où cela pourrait compliquer le débogage.

Ces interrupteurs -m sont supportés en plus de ceux ci-dessus sur les processeurs AMD x86-64 dans les environnements 64 bits.

-m32

-m64

Générer du code pour un environnement 32 ou 64 bits. L'environnement 32 bits fixe les int, long et pointeurs à 32 bits et génère du code qui tourne sur tout système i386. L'environnement 64 bits fixe les int, long et pointeurs à 64 bits et génère du code destiné à l'architecture AMD x86-64.

-mno-red-zone

Ne pas utiliser de zone dite « rouge » pour le code x86-64. La zone rouge est mandatée par l'ABI x86-64, elle est formée d'une zone de 128 octets située au-delà de l'emplacement du pointeur de pile qui ne sera pas modifiée par des gestionnaires de signaux ou d'interruptions et peut donc être utilisée pour des données temporaires sans devoir ajuster le pointeur de pile. Le drapeau -mno-red-zone désactive cette zone rouge.

-mcmodel=small

Générer du code pour le modèle de code restreint : le programme et ses symboles doivent être liés dans les 2 GB inférieurs de l'espace d'adressage. Les pointeurs font 64 bits. Les programmes peuvent être liés statiquement ou dynamiquement. C'est le modèle de code par défaut.

-mcmodel=kernel

Générer du code pour le modèle de code du noyau. Le noyau s'exécute dans les 2 GB négatifs de l'espace d'adressage. Ce modèle doit être utilisé pour le code du noyau Linux.

-mcmodel=medium

Générer du code pour le modèle intermédiaire : le programme est lié dans les 2 GB inférieurs de l'espace d'adressage mais les symboles peuvent être situés n'importe où dans l'espace d'adressage. Les programmes peuvent être liés statiquement ou dynamiquement, mais la construction de bibliothèques partagées n'est pas possible avec ce modèle.

-mcmodel=large

Générer du code pour le modèle étendu : ce modèle ne fait aucune supposition quant aux adresses et à la taille des sections. Actuellement, GCC n'implémente pas ce modèle.

Options HPPA

Ces options -m sont définies pour la famille d'ordinateurs HPPA :

-march=type-architecture

Générer du code pour l'architecture spécifiée. Les choix possibles pour type-architecture sont 1.0 pour PA 1.0, 1.1 pour PA 1.1, et 2.0 pour les processeurs PA 2.0. Référez-vous à /usr/lib/sched.models sur un système HP-UX pour déterminer l'option d'architecture correcte pour votre machine. Du code compilé pour des architectures de numéro inférieur bas tournera sur des architectures de numéro supérieur, mais pas l'inverse.

Le support PA 2.0 requiert actuellement gas snapshot 19990413 ou ultérieur. La prochaine version de binutils (actuellement 2.9.1) contiendra probablement le support PA 2.0.

-mpa-risc-1-0

-mpa-risc-1-1

-mpa-risc-2-0

Synonymes pour -march=1.0, -march=1.1 et -march=2.0 respectivement.

-mbig-switch

Générer du code convenant aux grandes tables de branchements. N'utilisez cette option que si l'assembleur/éditeur de liens se plaint de branchements hors d'atteinte dans une table de branchements.

-mjump-in-delay

Remplir les tranches de temps d'appels de fonction avec des instructions de saut inconditionnel en modifiant le pointeur de retour pour que l'appel de fonction soit la cible du saut conditionnel.

-mdisable-fpregs

Empêcher l'utilisation des registres flottants de quelque manière que ce soit. C'est nécessaire pour compiler des noyaux qui effectuent une commutation de contexte paresseuse des registres flottants. Si vous utilisez cette option et essayez d'effectuer des opérations flottantes, le compilateur échouera.

-mdisable-indexing

Empêcher le compilateur d'utiliser les modes d'adressage indexés. Cela évite quelques rares problèmes obscurs lors de la compilation de code généré par MIG sous MACH.

-mno-space-regs

Générer du code qui suppose que la cible ne dispose pas de registres d'espace. Cela permet à GCC de générer des appels indirects plus rapides, et d'utiliser des modes d'adressage indexés sans multiplicateur.

-mfast-indirect-calls

Générer du code qui suppose que les appels ne traversent jamais les frontières spatiales. Cela permet à GCC d'émettre du code qui effectue des appels indirects plus rapides.

Cette option ne fonctionnera pas en présence de bibliothèques partagées ou de fonctions imbriquées.

-mlong-load-store

Générer des séquences de chargement et de stockage de 3 instructions comme c'est parfois requis par l'éditeur de liens de HP-UX 10. C'est équivalent à l'option +k pour les compilateurs HP.

-mportable-runtime

Utiliser les conventions d'appel portables proposées par HP pour les systèmes ELF.

-mgas

Activer l'utilisation des directives assembleur comprises par le seul GAS.

-mschedule=type-cpu

Ordonnance le code en fonction des contraintes pour le type de machine type-cpu. Les choix possibles pour type-cpu sont 700, 7100, 7100LC, 7200 et 8000. Référez-vous à /usr/lib/sched.models sur un système HP-UX pour déterminer l'option d'ordonnancement correcte pour votre machine.

-mlinker-opt

Autoriser la passe d'optimisation dans l'éditeur de liens de HPUX. Notez que cela rend le débogage symbolique impossible. Cela déclenche également un bogue dans les éditeurs de liens de HPUX 8 et HPUX 9 où ils fournissent des messages d'erreur erronés lors de l'édition des liens de certains programmes.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises ne sont pas disponibles pour toutes les cibles HPPA. Normalement, les facilités du compilateur C usuel de cette machine sont utilisées, mais ceci ne peut être fait directement en compilation croisée. Vous devez vous arranger pour fournir les fonctions de bibliothèques convenant à la compilation croisée. La cible embarquée hppa1.1-*-pro fournit un support logiciel des flottants.

-msoft-float modifie la convention d'appel dans le fichier de sortie ; il n'est donc utile que si vous compilez tout un programme avec cette option. En particulier, vous devez compiler libgcc.a, la bibliothèque fournie avec GCC, avec -msoft-float pour que cela fonctionne.

Options Intel 960

Ces options -m sont définies pour les implémentations Intel 960 :

-mtype-cpu

Supposer les valeurs par défaut pour le type de machine type-cpu pour certaines des autres options, incluant l'ordonnancement des instructions, le support des flottants, et les modes d'adressage. Les choix pour type-cpu sont ka, kb, mc, ca, cf, sa et sb. Le type de cpu par défaut est kb.

-mnumerics

-msoft-float

L'option -mnumerics indique que le processeur supporte les instructions flottantes. L'option -msoft-float indique que le support des flottants ne devrait pas être présupposé.

-mleaf-procedures

-mno-leaf-procedures

Essayer (ne pas essayer) de modifier les procédures feuilles pour qu'elles soient appelables avec l'instruction « bal » aussi bien qu'avec « call ». Il en résultera un code plus efficace pour les appels explicites quand l'instruction « bal » peut être substituée par l'assembleur ou l'éditeur de liens, mais un code moins efficace dans d'autres cas, comme pour les appels via des pointeurs de fonction, ou quand on utilise un éditeur de liens ne supportant pas cette optimisation.

-mtail-call

-mno-tail-call

Faire (ou pas) des tentatives supplémentaires (en plus de celles des parties du compilateur indépendantes de la machine) d'optimiser les appels récursifs terminaux grâce à des branchements. Cela n'est pas conseillé, car la détection des cas où ce n'est pas valide n'est pas totalement achevée. -mno-tail-call est utilisé par défaut.

-mcomplex-addr

-mno-complex-addr

Supposer (ou ne pas supposer) que l'utilisation d'un mode d'adressage complexe génère un gain sur cette implémentation du i960. Des modes d'adressage complexes peuvent ne pas valoir le coup sur les séries K, mais ils le valent nettement sur les séries C. -mcomplex-addr est actuellement utilisé par défaut pour tous les processeurs sauf le CB et le CC.

-mcode-align

-mno-code-align

Aligner le code à des limites de 8 octets pour une recherche plus rapide (ou ne pas s'en soucier). Actuellement activé par défaut uniquement sur les implémentations de la série C.

-mic-compat

-mic2.0-compat

-mic3.0-compat

Permettre la compatibilité avec l'iC960 v2.0 ou v3.0.

-masm-compat

-mintel-asm

Permettre la compatibilité avec l'assembleur iC960.

-mstrict-align

-mno-strict-align

Permettre (ou pas) des accès non alignés.

-mold-align

Permettre la compatibilité au niveau alignement des structures avec la version 1.3 de la version Intel de gcc (basée sur gcc 1.37). Cette option implique -mstrict-align.

-mlong-double-64

Implémenter le type long double comme des nombres flottants 64 bits. Sans cette option, long double est implémenté par des nombres flottants 80 bits. La seule raison pour laquelle c'est supporté est qu'il n'y a pas encore de support des long double 128 bits dans fp-bit.c. Cette option n'est donc utile que pour les personnes utilisant des cibles flottantes logicielles. Sinon, nous recommandons de ne pas l'utiliser.

Options DEC Alpha

Ces options -m sont définies pour les implémentations DEC Alpha :

-mno-soft-float

-msoft-float

Utiliser (ne pas utiliser) les instructions flottantes matérielles pour les opérations flottantes. Quand -msoft-float est spécifié, des fonctions de libgcc.a seront utilisées pour effectuer des opérations flottantes. À moins qu'elles ne soient remplacées par des routines qui émulent les opérations flottantes, ou qu'elles soient compilées pour faire en sorte qu'elles appellent de telles routines d'émulation, ces routines émettront des opérations flottantes. Si vous compilez pour un Alpha ne disposant pas des opérations flottantes, vous devez vous assurer que la bibliothèque est construite de façon telle qu'elle ne les appelle pas.

Notez que les implémentations Alpha sans opérations flottantes sont requises pour avoir des registres flottants.

-mfp-reg

-mno-fp-regs

Générer du code qui utilise (n'utilise pas) le jeu de registres flottants. -mno-fp-regs implique -msoft-float. Si le jeu de registres flottants n'est pas utilisé, les opérandes flottants sont passés dans des registres entiers comme s'ils étaient des entiers et les résultats flottants sont passés dans « $0 » au lieu de « $f0 ». C'est une séquence d'appel non standard, et chaque fonction possédant un argument ou une valeur de retour flottante qui est appelée par du code compilé avec -mno-fp-regs doit donc également être compilée avec cette option.

Une utilisation typique de cette option est la création d'un noyau qui n'utilise aucun registre flottant, et donc n'a besoin ni d'en sauver, ni d'en restaurer.

-mieee

L'architecture Alpha implémente des flottants matériels optimisés pour obtenir une performance maximale. Elle est en grande partie conforme au standard des flottants IEEE. Néanmoins, pour une conformité totale, une assistance logicielle est nécessaire. Cette option génère du code entièrement conforme à IEEE sauf que le drapeau-inexact n'est pas maintenu (voyez ci-dessous). Si cette option est activée, la macro « _IEEE_FP » du préprocesseur CPP est définie durant la compilation. Le code résultant est moins efficace mais est capable de supporter correctement les nombres dénormalisés et les valeurs IEEE exceptionnelles comme pas-un-nombre (NaN) et plus ou moins l'infini. D'autres compilateurs Alpha appellent cette option -ieee_with_no_inexact.

-mieee-with-inexact

Comme -mieee, sauf que le code généré maintient aussi le drapeau-inexact IEEE. Activer cette option rend le code généré totalement compatible avec les maths IEEE. En plus de « _IEEE_FP », « _IEEE_FP_EXACT » est défini comme macro du préprocesseur. Sur certaines implémentations Alpha, le code résultant peut s'exécuter beaucoup plus lentement que le code généré par défaut. Puisqu'il n'y a très peu de code qui dépend du drapeau-inexact, vous ne devriez normalement pas spécifier cette option. D'autres compilateurs Alpha appellent cette option -ieee_with_inexact.

-mfp-trap-mode=mode-interruption

Cette option contrôle quelles interruptions relatives aux flottants il faut activer. D'autres compilateurs Alpha appellent cette option -fptm mode-interruption. Le mode d'interruption peut valoir l'une des quatre valeurs suivantes :

-mfp-rounding-mode=mode-arrondi

Sélectionner le mode d'arrondi IEEE. D'autres compilateurs Alpha appellent cette option -fprm mode-arrondi. Le mode-arrondi peut être :

-mtrap-precision=précision-interruption

Dans l'architecture Alpha, les interruptions flottantes sont imprécises. Cela signifie que sans une assistance logicielle, il est impossible se remettre d'une interruption flottante et l'exécution du programme doit normalement être terminée. GCC peut générer du code qui assiste les gestionnaires d'interruptions du système d'exploitation pour déterminer l'endroit exact où s'est produit une interruption flottante. En fonction des besoins d'une application, différents niveaux de précision peuvent être sélectionnés :

-mieee-conformant

Cette option marque le code généré comme étant conforme à IEEE. Vous ne devez pas utiliser cette option à moins que vous ne spécifiiez également -mtrap-precision=i et -mfp-trap-mode=su ou -mfp-trap-mode=sui. Son seul effet est d'émettre la ligne .eflag 48 dans le prologue de la fonction du fichier assembleur généré. Sous DEC Unix, cela a pour effet que les routines de bibliothèque mathématique conformes à IEEE seront intégrées lors de l'édition des liens.

-mbuild-constants

Normalement, GCC examine une constante entière 32 ou 64 bits pour voir s'il peut la construire à partir de constantes plus petites en deux ou trois instructions. S'il le peut, il émettra la constante comme un littéral et générera du code pour la charger à l'exécution à partir du segment de données.

Utilisez cette option pour indiquer à GCC de construire toutes les constantes entières en utilisant du code, même si cela prend plus d'instructions (le maximum est six).

Vous utiliseriez cette option typiquement pour construire un chargeur dynamique de bibliothèques partagées. Étant lui-même une bibliothèque partagée, il doit se reloger en mémoire avant qu'il puisse trouver les variables et les constantes dans son propre segment de données.

-malpha-as

-mgas

Indiquer s'il faut générer du code pouvant être assemblé par l'assembleur fourni par le vendeur (-malpha-as) ou par l'assembleur GNU -mgas.

-mbwx

-mno-bwx

-mcix

-mno-cix

-mfix

-mno-fix

-mmax

-mno-max

Indiquer si GCC doit générer du code pour utiliser les jeux d'instructions optionnels BWX, CIX, FIX et MAX. Le comportement par défaut est d'utiliser les jeux d'instructions supportés par le type de CPU spécifié via l'option -mcpu=, ou celui du CPU pour lequel GCC a été construit si aucun n'a été spécifié.

-mfloat-vax

-mfloat-ieee

Générer du code qui utilise (n'utilise pas) l'arithmétique flottante VAX F et G au lieu de la simple ou double précision IEEE.

-mexplicit-relocs

-mno-explicit-relocs

Des assembleurs Alpha anciens ne fournissaient aucun dispositif permettant de générer des relogements de symboles à l'exception des macros assembleur. Une de ces macros ne permet pas un ordonnancement optimal des instructions. Les binutils GNU supportent depuis la version 2.12 une nouvelle syntaxe qui permet au compilateur d'indiquer explicitement quels relogements devraient s'appliquer à quelles instructions. Cette option est principalement utile pour le débogage, car GCC détecte les capacités de l'assembleur quand il est construit et règle le défaut en conséquence.

-msmall-data

-mlarge-data

Quand -mexplicit-relocs est utilisé, les données statiques accessibles via des relogements relatifs-à-gp. Quand -msmall-data est utilisé, les objets faisant jusqu'à 8 octets de long sont placés dans une petite zone de données (les sections « .sdata » et « .sbss ») et peuvent être accédées via des relogements sur 16 bits par rapport au registre « $gp ». Ceci limite la taille de la petite zone de données à 64 Ko, mais permet aux variables d'être directement accessibles via une seule instruction.

L'option par défaut est -mlarge-data. Avec elle, la zone de données est limitée à un peu moins de 2 Go. Des programmes requérant plus de 2 Go de données doivent utiliser « malloc » ou « mmap » pour allouer les données dans le tas plutôt que dans le segment de données du programme.

Lors de la génération de code de bibliothèques partagées, -fpic implique -msmall-data et -fPIC implique -mlarge-data.

-mcpu=type-cpu

Fixer le jeu d'instructions et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Vous pouvez spécifier soit un nom du style EV, soit le numéro de puce correspondant. GCC supporte les paramètres d'ordonnancement des instructions pour les familles de processeurs EV4, EV5 et EV6 et choisira les valeurs par défaut pour le jeu d'instructions à partir du processeur que vous spécifiez. Si vous ne spécifiez pas de type de processeur, GCC utilisera par défaut le processeur pour lequel le compilateur a été construit.

Les valeurs supportées pour type-cpu sont

-mtune=type-cpu

Fixer uniquement les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Le jeu d'instructions n'est pas modifié.

-mmemory-latency=temps

Fixer la latence que devrait supposer l'ordonnanceur pour les références mémoire typiques comme vues par l'application. Ce nombre est fortement dépendant des modèles d'accès mémoire utilisés par l'application, et de la taille de la cache externe sur la machine.

Les options valides pour temps sont

Options DEC Alpha/VMS

Ces options -m sont définies pour les implémentations DEC Alpha/VMS :

-mvms-return-codes

Retourner des codes de condition VMS depuis main. Le comportement défaut consisté à retourner des codes de condition (p.ex. d'erreur) de style POSIX.

Options Clipper

Ces options -m sont définies pour les implémentations Clipper :

-mc300

Produire du code pour un processeur Clipper C300. C'est le comportement par défaut.

-mc400

Produire du code pour un processeur Clipper C400, c.-à-d. utiliser les registres flottants f8--f15.

Options H8/300

Ces options -m sont définies pour les implémentations H8/300 :

-mrelax

Raccourcir certaines références mémoire au moment de l'édition des liens, quand c'est possible ; utilise l'option -relax de l'éditeur de liens.

-mh

Générer du code pour le H8/300H.

-ms

Générer du code pour le H8/S.

-ms2600

Générer du code pour le H8/S2600. Cet interrupteur doit être utilisé avec -ms.

-mint32

Faire de « int » une valeur 32 bits par défaut.

-malign-300

Sur le H8/300H et H8/S, utiliser les mêmes règles d'alignement que pour le H8/300. Le comportement par défaut pour les H8/300H et H8/S est d'aligner les longs et les flottants à des limites de 4 octets. -malign-300 provoque leur alignement à des limites de 2 octets. Cette option n'a pas d'effet sur le H8/300.

Options SH

Ces options -m sont définies pour les implémentations SH :

-m1

Générer du code pour le SH1.

-m2

Générer du code pour le SH2.

-m3

Générer du code pour le SH3.

-m3e

Générer du code pour le SH3e.

-m4-nofpu

Générer du code pour le SH4 sans unité flottante.

-m4-single-only

Générer du code pour le SH4 avec une unité flottante ne supportant que l'arithmétique simple précision.

-m4-single

Générer du code pour le SH4 en supposant que l'unité flottante est en mode simple précision par défaut.

-m4

Générer du code pour le SH4.

-mb

Compiler du code pour le processeur en mode gros-boutiste.

-ml

Compiler du code pour le processeur en mode petit-boutiste.

-mdalign

Aligner les doubles à des limites de 64 bits. Notez que cela modifie les conventions d'appel, et certaines fonctions de la bibliothèque C standard ne fonctionneront donc pas à moins que vous ne la recompiliez d'abord avec -mdalign.

-mrelax

Raccourcir certaines références mémoire au moment de l'édition des liens, quand c'est possible ; utilise l'option -relax de l'éditeur de liens.

-mbigtable

Utiliser des décalages de 32 bits dans les tables de branchements. Le comportement par défaut est d'utiliser des décalages de 16 bits.

-mfmovd

Permettre l'utilisation de l'instruction « fmovd ».

-mhitachi

Se conformer aux conventions d'appel définies par Hitachi.

-mnomacsave

Marquer le registre « MAC » comme étant corrompu par l'appel, même si -mhitachi est fourni.

-mieee

Accroître la conformité IEEE du code flottant.

-misize

Décharger la taille et la localisation de l'instruction dans le code assembleur.

-mpadstruct

Cette option est dépréciée. Elle bourre les structures jusqu'à un multiple de 4 octets, ce qui est incompatible avec l'ABI SH.

-mspace

Optimiser pour l'espace au lieu de la vitesse. Impliqué par -Os.

-mprefergot

Lors de la génération de code indépendant de la position, émettre des appels de fonction en utilisant la table de décalages globale (Global Offset Table, GOT) au lieu de la table de liaison de procédures (Procedure Linkage Table).

-musermode

Générer un appel de fonction de bibliothèque pour invalider les entrées du cache d'instructions, après avoir corrigé un trampoline (NdT : bloc de code permettant de préparer un contexte d'appel pour une autre fonction). Cet appel de fonction de bibliothèque ne suppose pas qu'il puisse écrire dans l'espace d'adressage mémoire complet. C'est le comportement par défaut quand la cible est « sh-*-linux* ».

Options pour System V

Ces options additionnelles sont disponibles sur System V Release 4 pour la compatibilité avec les autres compilateurs sur ces systèmes :

-G

Créer un objet partagé. Il est recommandé d'utiliser -symbolic ou -shared à la place.

-Qy

Identifier les versions de chaque outil utilisé par le compilateur, dans une directive d'assemblage « .ident » dans la sortie.

-Qn

Ne pas ajouter de directives « .ident » dans le fichier de sortie (c'est le comportement par défaut).

-YP,répertoires

Rechercher les bibliothèques spécifiées avec -l dans les répertoires répertoires, et aucun autre.

-Ym,répertoire

Recherche le préprocesseur M4 dans le répertoire répertoire. L'assembleur utilise cette option.

Options TMS320C3x/C4x

Ces options -m sont définies pour les implémentations TMS320C3x/C4x :

-mcpu=type-cpu

Fixer le jeu d'instructions, le jeu de registres, et les paramètres d'ordonnancement des instructions pour le type de machine type-cpu. Les valeurs supportées pour type-cpu sont c30, c31, c32, c40 et c44. Le type de machine par défaut est c40 qui indique de générer du code pour le TMS320C40.

-mbig-memory

-mbig

-msmall-memory

-msmall

Générer du code pour le modèle de mémoire étendu ou restreint. Le modèle de mémoire restreint supposait que toutes les données tenaient dans une page de 64 Ko. Au moment de l'exécution, le registre de page de données (Data Page, DP) doit pointer vers la page de 64 K contenant les sections de programme .bss et .data. Le modèle de mémoire étendu est utilisé par défaut et requiert le rechargement du registre DP pour chaque accès mémoire direct.

-mbk

-mno-bk

Permettre (interdire) l'allocation d'opérandes entiers généraux dans le registre de comptage de blocs BK.

-mdb

-mno-db

Activer (désactiver) la génération de code utilisant les instructions Decrement And Branch (décrémenter et brancher), DBcond(D). C'est activé par défaut pour le C4x. Par sécurité, c'est désactivé pour le C3x, puisque le nombre maximum d'itérations sur le C3x est 2^{23 + 1} (mais qui itère des boucles plus de 2^{23} fois sur le C3x ? ). Notez que GCC essaiera de renverser une boucle afin qu'il puisse utiliser l'instruction de décrémentation et de branchement, mais abandonnera s'il y a plus d'une référence mémoire dans la boucle. Une boucle dont le compteur de boucle est décrémenté peut donc générer du code légèrement plus efficace, dans les cas où l'instruction RPTB ne peut être utilisée.

-mdp-isr-reload

-mparanoid

Forcer la sauvegarde du registre DP à l'entrée d'une routine de service d'interruption (ISR), son rechargement à ce moment dans la section de données, et sa restauration à la sortie de l'ISR. Cela ne devrait pas être requis sauf si quelqu'un a violé le modèle de mémoire restreint en modifiant le registre DP, par exemple dans une bibliothèque objet.

-mmpyi

-mno-mpyi

Pour le C3x, utiliser l'instruction 24 bits MPYI pour les multiplications d'entiers au lieu d'un appel de bibliothèque pour garantir des résultats sur 32 bits. Notez que si l'un des opérandes est une constante, alors la multiplication sera effectuée en utilisant des décalages et des additions. Si l'option -mmpyi n'est pas spécifiée pour le C3x, alors les opérations de prise de racine carrée sont effectuées en ligne au lieu de via un appel de bibliothèque.

-mfast-fix

-mno-fast-fix

L'instruction C3x/C4x FIX, pour convertir une valeur flottante en valeur entière, choisit l'entier le plus proche plus petit ou égal à la valeur flottante plutôt que l'entier le plus proche. Donc, si le nombre flottant est négatif, le résultat sera incorrectement tronqué ; un code additionnel est nécessaire pour détecter et corriger ce cas. Cette option peut être utilisée pour désactiver la génération du code additionnel requis pour corriger le résultat.

-mrptb

-mno-rptb

Activer (désactiver) la génération de séquences de blocs de répétitions (repeat block sequences) utilisant l'instruction RPTB pour une surcharge de bouclage nulle. La construction RPTB n'est utilisée que pour les boucles les plus internes qui n'appellent pas de fonction ni ne sautent en dehors des limites de la boucle. Il n'y a aucun avantage à avoir des boucles RPTB imbriquées, à cause de la surcharge requise pour sauver et restaurer les registres RC, RS et RE. C'est activé par défaut avec -O2.

-mrpts=nombre

-mno-rpts

Activer (désactiver) l'utilisation de l'instruction de répétition employant une seule instruction RPTS. Si un bloc de répétition contient une seule instruction, et que l'on peut garantir que le nombre de boucles vaut moins de nombre, GCC émettra une instruction RPTS au lieu d'une instruction RPTB. Si aucune valeur n'est spécifiée, alors un RPTS sera émis même si le nombre de boucles ne peut être déterminé au moment de la compilation. Notez que l'instruction répétée suivant RPTS ne doit pas être rechargée à partir de la mémoire à chaque itération, libérant ainsi les bus CPU pour les opérandes. Néanmoins, puisque les interruptions sont bloquées par cette instruction, elle est désactivée par défaut.

-mloop-unsigned

-mno-loop-unsigned

Le nombre maximum d'itérations lors de l'utilisation de RPTS et RPTB (et DB sur le C40) est 2^{31 + 1} puisque ces instructions testent si le nombre d'itérations est négatif pour terminer la boucle. Si le nombre d'itérations est non signé, il y a une possibilité que le nombre maximum d'itérations de 2^{31 + 1} puisse être dépassé. Cet interrupteur autorise un nombre d'itérations non signé.

-mti

Essayer d'émettre une syntaxe assembleur que comprend l'assembleur TI (asm30). Cela renforce également la compatibilité avec l'API utilisée par le compilateur TI C3x C. Par exemple, les long doubles sont passés dans des structures plutôt que dans des registres flottants.

-mregparm

-mmemparm

Générer du code qui utilise les registres (la pile) pour passer des arguments aux fonctions. Par défaut, les arguments sont passés dans des registres quand c'est possible plutôt que de les placer sur la pile.

-mparallel-insns

-mno-parallel-insns

Permettre la génération d'instructions parallèles. C'est activé par défaut avec -O2.

-mparallel-mpy

-mno-parallel-mpy

Permettre la génération des instructions parallèles MPY⎪⎪ADD et MPY⎪⎪SUB, à condition que -mparallel-insns soit également spécifié. Ces instructions souffrent de contraintes serrées sur les registres qui peuvent affecter la génération de code pour les grosses fonctions.

Options V850

Ces options -m sont définies pour les implémentations V850 :

-mlong-calls

-mno-long-calls

Traiter tous les appels comme étant lointains (proches). Si les appels sont supposés être lointains, le compilateur chargera toujours l'adresse de la fonction dans un registre, et l'appellera indirectement via le pointeur.

-mno-ep

-mep

Ne pas optimiser (optimiser) les blocs de base qui utilisent le même pointeur d'index 4 fois ou plus pour copier le pointeur dans le registre « ep », et utiliser les instructions plus courtes « sld » et « sst ». L'option -mep est activée par défaut si vous optimisez.

-mno-prolog-function

-mprolog-function

Utiliser (ne pas utiliser) de fonctions externes pour sauver et restaurer des registres au prologue et à l'épilogue d'une fonction. Les fonctions externes sont plus lentes, mais utilisent moins d'espace de code si plus d'une fonction sauve le même nombre de registres. L'option -mprolog-function est activée par défaut si vous optimisez.

-mspace

Essayer de rendre le code le plus compact possible. Actuellement, cela active simplement les options -mep et -mprolog-function.

-mtda=n

Placer les variables statiques ou globales dont la taille est d'au plus n octets dans la minuscule zone de données vers laquelle pointe le registre « ep ». La minuscule zone de données peut contenir jusqu'à 256 octets au total (128 octets pour les références d'octets).

-msda=n

Placer les variables statiques ou globales dont la taille est d'au plus n octets dans la petite zone de données vers laquelle pointe le registre « gp ». La petite zone de données peut contenir jusqu'à 64 Ko.

-mzda=n

Placer les variables statiques ou globales dont la taille est d'au plus n octets dans les 32 premiers Ko de la mémoire.

-mv850

Spécifier que le processeur cible est le V850.

-mbig-switch

Générer du code convenant aux grandes tables de branchements. N'utilisez cette option que si l'assembleur/éditeur de liens se plaint de branchements hors d'atteinte à l'intérieur d'une table de branchements.

Options ARC

Ces options sont définies pour les implémentations ARC :

-EL

Compiler du code pour le mode petit-boutiste. C'est le comportement par défaut.

-EB

Compiler du code pour le mode gros-boutiste.

-mmangle-cpu

Ajouter le nom du cpu au début de tous les noms de symboles publics. Dans les systèmes multi-processeurs, il y a de nombreuses variantes ARC avec différentes caractéristiques de jeux d'instructions et de registres. Ce drapeau empêche que du code compilé pour un cpu puisse être lié avec du code compilé pour un autre. Aucun mécanisme n'existe pour le traitement de variantes comme les « presque identique ». C'est une option tout ou rien.

-mcpu=cpu

Compiler du code pour la variante de processeur ARC cpu. Les variantes qui sont supportées dépendent de la configuration. Toutes les variantes supportent -mcpu=base, c'est le comportement par défaut.

-mtext=section-texte

-mdata=section-données

-mrodata=section-données-lecture-seule

Placer les fonctions, les données et les données accessibles en lecture uniquement dans les section-texte, section-données et section-données-lecture-seule respectivement par défaut. Cela peut être surchargé avec l'attribut « section ».

Options NS32K

Voici les options -m définies pour la série 32000. Les valeurs par défaut pour ces options dépendent du style de 32000 qui a été sélectionné quand le compilateur a été configuré ; celles pour la plupart des choix courants sont fournies plus bas.

-m32032

-m32032

Générer une sortie pour un 32032. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32032 ou de 32016.

-m32332

-m32332

Générer une sortie pour un 32332. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32332.

-m32532

-m32532

Générer une sortie pour un 32532. C'est le comportement par défaut quand le compilateur est configuré pour les systèmes à base de 32532.

-m32081

Générer une sortie contenant des instructions 32081 pour flottants. C'est le comportement par défaut sur tous les systèmes.

-m32381

Générer une sortie contenant des instructions 32381 pour flottants. Cela implique également -m32081. Le 32381 n'est compatible qu'avec les processeurs 32332 et 32532. C'est le comportement par défaut pour la configuration pc532-netbsd.

-mmulti-add

Essayer de générer des instructions flottantes multiplier-additionner « polyF » et « dotF ». Cette option n'est disponible que si l'option -m32381 est utilisée. Utiliser ces instructions requiert des modifications à l'allocation des registres qui ont généralement un impact négatif sur les performances. Cette option ne devrait être activée que lors de la compilation de code particulièrement enclin à faire un usage intensif des instructions multiplier-additionner.

-mnomulti-add

Ne pas essayer de générer les instructions flottantes multiplier-additionner « polyF » et « dotF ». C'est le comportement par défaut sur toutes les plate-formes.

-msoft-float

Générer une sortie contenant des appels de bibliothèque pour flottants. Avertissement : les bibliothèques requises peuvent ne pas être disponibles.

-mnobitfield

Ne pas utiliser les instructions champ-bit. Sur certaines machines, il est plus rapide d'utiliser des opérations de décalage et de masquage. C'est le comportement par défaut pour le pc532.

-mbitfield

Utiliser les instructions champ-bit. C'est le comportement par défaut pour toutes les plate-formes sauf le pc532.

-mrtd

Utiliser une convention d'appel de fonction différente, dans laquelle les fonctions prenant un nombre fixé d'arguments retournent à l'appelant en dépilant leurs arguments en sortie avec l'instruction « ret ».

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

Vous devez également fournir des prototypes de fonction pour toutes les fonctions prenant un nombre variable d'arguments (incluant « printf ») ; sinon, du code incorrect sera généré pour les appels à ces fonctions.

En plus, un code gravement incorrect en résultera si vous appelez une fonction avec un nombre trop élevé d'arguments. (Normalement, les arguments excédentaires sont ignorés sans dommage.)

Cette option tire son nom de l'instruction 680x0 « rtd ».

-mregparam

Utiliser une convention d'appel de fonction différente, dans laquelle les deux premiers arguments sont passés dans des registres.

Cette convention d'appel est incompatible avec celle utilisée normalement sous Unix, et vous ne pourrez donc pas l'utiliser si vous devez appeler des bibliothèques compilées avec le compilateur Unix.

-mnoregparam

Ne pas passer d'arguments dans les registres. C'est le comportement par défaut pour toutes les cibles.

-msb

On peut utiliser sb comme un registre d'index qui vaut toujours zéro. C'est le comportement par défaut pour la cible pc532-netbsd.

-mnosb

Le registre n'est pas disponible pour utilisation ou n'a pas été initialisé à zéro par le système d'exécution. C'est le comportement par défaut pour toutes les cibles sauf le pc532-netbsd. C'est également impliqué à chaque fois que -mhimem ou -fpic est utilisé.

-mhimem

Beaucoup de modes d'adressage de la série ns32000 utilisent des déplacements pouvant aller jusqu'à 512 Mo. Si une adresse est située au-delà de 512 Mo, alors les déplacements à partir de zéro ne peuvent être utilisés. Cette option provoque la génération de code qui peut être chargé au-delà de 512 Mo. Cela peut être utile pour les systèmes d'exploitation, ou pour du code de la ROM.

-mnohimem

Supposer que du code sera chargé dans les 512 premiers Mo d'espace d'adressage virtuel. C'est le comportement par défaut pour toutes les plate-formes.

Options AVR

Ces options sont définies pour les implémentations AVR :

-mmcu=mcu

Spécifier le jeu d'instructions AVR ATMEL ou le type MCU.

Le jeu d'instructions avr1 est destiné au coeur AVR minimal, non supporté par le compilateur C, uniquement pour les programmes assembleur (types MCU : at90s1200, attiny10, attiny11, attiny12, attiny15, attiny28).

Le jeu d'instructions avr1 est destiné au coeur AVR classique avec jusqu'à 8 K d'espace mémoire pour le programme (types MCU: at90s2313, at90s2323, attiny22, at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515, at90c8534, at90s8535).

Le jeu d'instructions avr1 est destiné au coeur AVR classique avec jusqu'à 128 Ko d'espace mémoire pour le programme (types MCU : atmega103, atmega603, at43usb320, at76c711).

Le jeu d'instructions avr1 est destiné au coeur AVR amélioré avec jusqu'à 8 Ko d'espace mémoire pour le programme (types MCU: atmega8, atmega83, atmega85).

Le jeu d'instructions avr1 est destiné au coeur AVR amélioré avec jusqu'à 128 Ko d'espace mémoire pour le programme (types MCU : atmega16, atmega161, atmega163, atmega32, atmega323, atmega64, atmega128, at43usb355, at94k).

-msize

Émettre la taille des instructions dans le fichier assembleur.

-minit-stack=N

Spécifier l'adresse initiale de la pile, qui peut être un symbole ou une valeur numérique (__stack par défaut).

-mno-interrupts

Le code généré n'est pas compatible avec les interruptions matérielles. La taille du code sera plus petite.

-mcall-prologues

Les prologues/épilogues des fonctions sont développés en appels aux sous-routines appropriées. La taille du code sera plus petite.

-mno-tablejump

Ne pas générer d'instructions de saut de table qui accroissent parfois la taille du code.

-mtiny-stack

Ne modifier que les 8 bits de poids faible du pointeur de pile.

Options MCore

Voici les options -m définies pour les processeurs Motorola M*Core :

-mhardlit

-mhardlit

-mno-hardlit

Mettre en ligne les constantes dans le flux du programme si cela peut être fait en deux instructions ou moins.

-mdiv

-mdiv

-mno-div

Utiliser l'instruction de division divide. (Activé par défaut).

-mrelax-immediate

-mrelax-immediate

-mno-relax-immediate

Autoriser des valeurs immédiates de taille quelconque dans les opérations sur les bits.

-mwide-bitfields

-mwide-bitfields

-mno-wide-bitfields

Toujours traiter les champs-bit comme s'ils avaient la taille d'un int.

-m4byte-functions

-m4byte-functions

-mno-4byte-functions

Forcer toutes les fonctions à être alignées à des limites de quatre octets.

-mcallgraph-data

-mcallgraph-data

-mno-callgraph-data

Émettre de l'information sur le graphe des appels.

-mslow-bytes

-mslow-bytes

-mno-slow-bytes

Préférer l'accès mot lors de la lecture de quantités de taille d'un octet.

-mlittle-endian

-mlittle-endian

-mbig-endian

Générer du code pour une cible petit-boutiste.

-m210

-m210

-m340

Générer du code pour le processeur 210.

Options IA-64

Voici les options -m définies pour l'architecture Intel IA-64 :

-mbig-endian

Générer du code pour une cible gros-boutiste. C'est le comportement par défaut pour HPUX.

-mlittle-endian

Générer du code pour une cible petit-boutiste. C'est le comportement par défaut pour AIX5 et Linux.

-mgnu-as

-mno-gnu-as

Générer (ou pas) du code pour l'assembleur GNU. C'est le comportement par défaut.

-mgnu-ld

-mno-gnu-ld

Générer (ou pas) du code pour l'éditeur de liens GNU. C'est le comportement par défaut.

-mno-pic

Générer du code qui n'utilise pas de registre de pointeur global. Le résultat n'est pas un code indépendant de la position, et viole l'ABI IA-64.

-mvolatile-asm-stop

-mno-volatile-asm-stop

Générer (ou pas) un bit d'arrêt immédiatement avant et après des instructions assembleur volatiles.

-mb-step

Générer du code qui contourne l'erreur de pas de l'Itanium B.

-mregister-names

-mno-register-names

Générer (ou pas) les noms de registres in, loc et out pour les registres empilés. Cela peut rendre plus lisible la sortie de l'assembleur.

-mno-sdata

-msdata

Désactiver (ou activer) les optimisations qui utilisent la petite section de données. Cela peut être utile pour contourner des bogues de l'optimiseur.

-mconstant-gp

Générer du code qui utilise une seule valeur de pointeur global constant. C'est utile quand on compile du code du noyau.

-mauto-pic

Générer du code qui est auto-relogeable. Ceci implique -mconstant-gp. C'est utile quand on compile du firmware.

-minline-divide-min-latency

Générer du code pour les divisions en ligne en utilisant l'algorithme de latence minimale.

-minline-divide-max-throughput

Générer du code pour les divisions en ligne en utilisant l'algorithme de débit maximum.

-mno-dwarf2-asm

-mdwarf2-asm

Générer (ou pas) du code assembleur code pour l'information de débogage DWARF2 sur les numéros de ligne. Cela peut être utile quand on n'utilise pas l'assembleur GNU.

-mfixed-range=intervalle-registres

Générer du code traitant l'intervalle de registres fournis comme des registres fixes. Un registre fixe est un registre que l'allocateur de registres ne peut utiliser. C'est utile quand on compile du code du noyau. Un intervalle de registres est spécifié par deux registres séparés par un tiret. Des intervalles de registres multiples peuvent être spécifiés en les séparant par des virgules.

Options D30V

Ces options -m sont définies pour les implémentations D30V :

-mextmem

Lier les sections .text, .data, .bss, .strings, .rodata, .rodata1 et .data1 en mémoire externe, qui débute à l'emplacement « 0x80000000 ».

-mextmemory

Identique à l'interrupteur -mextmem.

-monchip

Lier la section .text dans la mémoire texte sur la puce, qui débute à l'emplacement « 0x0 ». Lier également les sections .data, .bss, .strings, .rodata, .rodata1 et .data1 dans la mémoire de données sur la puce, qui débute à l'emplacement « 0x20000000 ».

-mno-asm-optimize

-masm-optimize

Désactiver (activer) le passage de -O à l'assembleur lors de l'optimisation. L'assembleur utilise l'option -O pour paralléliser des instructions courtes adjacentes quand c'est possible.

-mbranch-cost=n

Accroître les coûts internes des branchements à n. Des coûts plus élevés signifient que le compilateur émettra plus d'instructions pour éviter de devoir faire un branchement. La valeur par défaut est 2.

-mcond-exec=n

Spécifier le nombre maximum d'instructions exécutées conditionnellement qui remplacent un branchement. La valeur par défaut est 4.

Options S/390 et zSeries

Voici les options -m définies pour les architectures S/390 et zSeries :

-mhard-float

-msoft-float

Utiliser (ne pas utiliser) les instructions et registres flottants pour les opérations flottantes. Quand -msoft-float est spécifié, les fonctions de libgcc.a seront utilisées pour effectuer des opérations flottantes. Quand -mhard-float est spécifié, le compilateur génère des instructions flottantes IEEE. C'est le comportement par défaut.

-mbackchain

-mno-backchain

Générer (ne pas générer) du code qui conserve un chaînage arrière explicite à l'intérieur du cadre de pile qui pointe vers le cadre de l'appelant. Ce n'est actuellement nécessaire que pour permettre le débogage. Le comportement par défaut est de générer le chaînage arrière.

-msmall-exec

-mno-small-exec

Générer (ne pas générer) du code qui utilise l'instruction « bras » pour effectuer des appels de sous-routines. Cela ne fonctionne fiablement que si la taille totale de l'exécutable ne dépasse pas 64 Ko. Le comportement par défaut est d'utiliser l'instruction « basr » à la place, qui ne souffre pas de cette limitation.

-m64

-m31

Quand -m31 est spécifié, générer du code conforme à Linux pour l'ABI S/390. Quand -m64 est spécifié, générer du code conforme à Linux pour l'ABI zSeries. Cela permet en particulier à GCC de générer des instructions 64 bits. Pour les cibles s390, l'option par défaut est -m31, alors qu'elle est -m64 pour les cibles s390x.

-mmvcle

-mno-mvcle

Générer (ne pas générer) du code qui utilise l'instruction « mvcle » pour effectuer des déplacements de blocs. Quand -mno-mvcle est spécifié, utiliser une boucle « mvc » à la place. C'est le comportement par défaut.

-mdebug

-mno-debug

Afficher (ne pas afficher) des informations de débogage additionnelles lors de la compilation. Le comportement par défaut est d'afficher aucune information de débogage.